Suporte no desenvolvimento de jogos


    [AJUDA] Khas Effect no VXA-OS

    Haseo
    Haseo
    Ocasional
    Ocasional

    Mensagens : 167
    Créditos : 4
    Cash : 0

    [AJUDA] Khas Effect no VXA-OS Empty [AJUDA] Khas Effect no VXA-OS

    Mensagem por Haseo em Dom Ago 04, 2019 2:16 pm

    Opa! Opa! Pessoal alguem pode me ajudar com esse bug ?
    Simplesmente a tela fica assim quando eu ativo o sistema de Effect Light do Khas.

    [AJUDA] Khas Effect no VXA-OS Print10

    Script:
    Código:
    #-------------------------------------------------------------------------------
    # * [ACE] Khas Awesome Light Effects
    #-------------------------------------------------------------------------------
    # * Por Khas Arcthunder - arcthunder.site40.net
    # * Versão: 1.0 BR
    # * Lançada em: 12/01/2012
    #
    #-------------------------------------------------------------------------------
    # * Termos de uso
    #-------------------------------------------------------------------------------
    # Ao utilizar qualquer script feito por Khas, você concorda com os termos abaixo
    # 1. Você deve dar crédito a Khas se estiver usando algum script Khas;
    # 2. Todos os scripts Khas estão sob licença Creative Commons;
    # 3. Todos os scripts Khas são para projetos não comerciais, se você precisar de
    #    algum script Khas em seu projeto comercial (aceito pedidos para esse tipo
    #    de projeto), envie um email para nilokruch@live.com com o pedido;
    # 4. Todos os scripts Khas são para uso pessoal, você pode usar e editar para uso
    #    no seu projeto, porém você não pode postar nenhuma versão modificada;
    # 5. Você não pode dar créditos a si próprio por postar algum script Khas;
    # 6. Caso queira compartilhar um script Khas, não poste o link direto de
    #    download, apenas redirecione o usuário para arcthunder.site40.net
    #
    #-------------------------------------------------------------------------------
    # * Características
    #-------------------------------------------------------------------------------
    # - Efeitos de luz realista
    # - Luz real (não passa paredes!)
    # - Fontes de luz estática (que não se move)
    # - Fonte de luz dinâmica (uma lanterna para o jogador, por exemplo)
    # - Efeitos multiplos podem se juntar
    # - Fácil configuração
    # - Uso por comentário
    #
    #-------------------------------------------------------------------------------
    # * IMPORTANTE - Desempenho
    #-------------------------------------------------------------------------------
    # Esse script pode vir a ser pesado para processadores muito antigos! O Awesome
    # Light Effects foi testado em um Core 2 Duo E4500 e em um Core i5, sem lag.
    # Porém, além do processador, há vários fatores que influenciam no desempenho
    # do script:
    #
    # 1. Tamanho do mapa
    # Este script analiza o mapa em busca de superfícies para cortar a luz. Em um
    # mapa muito grande, esse número de superfícies pode aumentar muito, afetando
    # o desempenho da LUZ DINÂMICA. O tamanho do mapa não influência nas luzes
    # estáticas.
    #
    # 2. Quantidade de efeitos
    # Este script desenha os efeitos na tela, conforme sua posição. Antes de
    # atualizá-los, a sua posição é verificada. Portanto, em mapas muito grandes
    # com excesso de efeitos pode a vir ocorrer lag. Note que isso é apenas uma
    # previsão, pois nos testes atuais não foi detectado lag.
    #
    # 3. Tamanho da imagem
    # O tamanho da imagem da luz dinâmica influencia diretamente no desempenho.
    # O corte de luz é feito linha a linha, quanto maior a resolução da imagem,
    # mais tempo será gasto para cortá-la. A recomendação é até 200x200 pixels.
    #
    #-------------------------------------------------------------------------------
    # * IMPORTANTE - Imagens de luz
    #-------------------------------------------------------------------------------
    # Para o funcionamento correto do script, as imagens de luz DEVEM obedecer
    # os seguintes critérios:
    #
    # 1. O tamanho da imagem DEVE ser par. Exemplo: 150x150
    # 2. A imagem DEVE ser quadrada, com dimensões IGUAIS. Exemplo: 156x156
    # 3. A imagem DEVE estar com as cores invertidas! Isso é nescessário, pois o
    #    script inverte as cores para desenhar o efeito na superfície de efeitos.
    #    Lembre-se que a cor preta ficará transparente!
    #
    #-------------------------------------------------------------------------------
    # * Instruções - 1. Configurando efeitos estáticos
    #-------------------------------------------------------------------------------
    # Para configurar efeitos estáticos, vá até a configuração (logo abaixo) e
    # defina os efeitos dentro da hash Effects. Faça do seguinte modo:
    #
    # X => [imagem, opacidade, variação, corte],  <= Lembre dessa vírgula no final!
    #
    # Onde:
    # Imagem => Nome da imagem na pasta "Graphics/Lights";
    # Opacidade => Opacidade da imagem;
    # Variação => Variação POSITIVA da opacidade;
    # Corte => Coloque true para cortar a imagem e false para não cortar;
    # X => É o ID do efeito, para ser usado nos eventos. Use um ID para cada efeito.
    #
    # Veja os efeitos pré configurados para entender como funciona.
    #
    #-------------------------------------------------------------------------------
    # * Instruções - 2. Usando o efeitos em eventos:
    #-------------------------------------------------------------------------------
    # Para usar o efeito definido em um evento, coloque o seguinte comentário:
    #
    # [light x]
    #
    # Onde x deve ser o ID do efeito configurado.
    #
    #-------------------------------------------------------------------------------
    # * Instruções - 3. Utilizando a luz dinâmica (lanterna)
    #-------------------------------------------------------------------------------
    # A lanterna é automaticamente inicializada como invisível. Você pode usar os
    # seguintes métodos com o comando "Chamar Script":
    #
    # l = $game_map.lantern
    # Adiquire a lanterna em uma variável.
    # Você pode usar todos os comandos abaixo com "$game_map.lantern" ao
    # invés de adiquirir a lanterna em uma variável, porém tome cuidado, pois
    # o comando "Chamar Script" corta o código e pode gerar erros.
    #
    # l.set_graphic(i)
    # Muda o gráfico da lanterna para i, onde i deve ser o nome, entre aspas,
    # da imagem na pasta Graphics/Lights
    #
    # l.set_multiple_graphics(h)
    # Muda os gráficos da lanterna para h, onde h deve ser uma Hash com o seguinte
    # formato:
    #
    # h = {2=>"ld",4=>"ll",6=>"lr",8=>"lu"}
    #
    # Onde:
    # "ld" é o nome da imagem quando o portador está virado para baixo;
    # "ll" é o nome da imagem quando o portador está virado para esquerda;
    # "lr" é o nome da imagem quando o portador está virado para direita;
    # "lu" é o nome da imagem quando o portador está virado para cima.
    #
    # l.change_owner(char)
    # Muda o portador da lanterna para char, onde char pode ser:
    # $game_player          <= O jogador;
    # self_event            <= O evento em que o comando é chamado;
    # $game_map.events[x]    <= O evento de ID x do mapa.
    #
    # l.set_opacity(o,p)
    # Ajusta a opacidade da lanterna, onde:
    # o é a opacidade padrão;
    # p é a variação POSITIVA da opacidade.
    #
    # l.show
    # Depois de configurar a lanterna com os comandos acima, use este comando para
    # tornar a lanterna visível.
    #
    # l.hide
    # Use este comando para esconder a lanterna.
    #
    #-------------------------------------------------------------------------------
    # * Instruções - 4. Utilizando a superfície de efeitos (Chamar Script)
    #-------------------------------------------------------------------------------
    # O Awesome Light Effects desenha os efeitos sobre uma superfície. Para que
    # os efeitos estejam visíveis, a superfície de efeitos deve estar visível.
    # Para utilizar a superfície de efeitos, utilize os comandos abaixo:
    #
    # s = $game_map.effect_surface
    # Adiquire a superfície em uma variável.
    # Você pode usar todos os comandos abaixo com "$game_map.effect_surface" ao
    # invés de adiquirir a superfície em uma variável, porém tome cuidado, pois
    # o comando "Chamar Script" corta o código e pode gerar erros.
    #
    # s.set_color(r,g,b)
    # Muda a cor da superfície instantâneamente para a cor fornecida:
    # r => valor da cor vermelha;
    # g => valor da cor verde;
    # b => valor da cor azul.
    #
    # s.set_alpha(a)
    # Muda a opacidade da superfície instantâneamente para a.
    #
    # s.change_color(time,r,g,b)
    # Muda SOMENTE a cor da superfície em um certo tempo, onde:
    # time => tempo para a mudança (em frames);
    # r => valor da cor vermelha;
    # g => valor da cor verde;
    # b => valor da cor azul.
    #
    # s.change_color(time,r,g,b,a)
    # Muda a cor da superfície e a opacidade em um certo tempo, onde:
    # time => tempo para a mudança (em frames);
    # r => valor da cor vermelha;
    # g => valor da cor verde;
    # b => valor da cor azul;
    # a => opacidade.
    #
    # s.change_alpha(time,a)
    # Muda a opacidade da superfície em um certo tempo, onde:
    # time => tempo para a mudança (em frames);
    # a => opacidade.
    #
    #-------------------------------------------------------------------------------
    # * Instruções - 5. Utilizando a superfície de efeitos (Evento)
    #-------------------------------------------------------------------------------
    # Você pode acessar a superfície de efeitos pelo comando "Tonalidade de Tela",
    # para isso, coloque a opção "Surface_UE" (nas configurações) como true. Caso
    # queria desabilitar essa opção e ter controle sobre o tom da tela, coloque a
    # opção "Surface_UE" como false.
    #
    # Observe os seguintes detalhes, se for usar esta opção:
    # 1. Os valores de cor devem estar entre 0 e 255;
    # 2. O tempo é em frames;
    # 3. O valor "Cinza" será enviado como a opacidade da superfície.
    #
    #-------------------------------------------------------------------------------
    # * Instruções - 6. Configurando as Tags do mapa
    #-------------------------------------------------------------------------------
    # Afim de que as luzes sejam cortadas de forma precisa e realista, há 3 tipos
    # de comportamento para um tile: telhado, parede e bloco. Pense de maneira
    # lógica: um telhado gera sombras como telhado, uma parede como uma parede, e
    # assim por diante.
    #
    # Para isso, as tags do tileset DEVEM ser configuradas. Por padrão, são
    # configuradas para 6,7 e 8. Veja a demo para ter noção de como isso funciona.
    #
    # Note que o script só irá analizar a primeira camada (camada A) do mapa. Certos
    # tilesets não irão funcionar caso os tiles não estejam configurados de modo
    # correto. Note ainda que este script depende do bom mapeamento para funcionar,
    # preste atenção aos detalhes do seu mapa.
    #
    #-------------------------------------------------------------------------------
    # * Configuração
    #-------------------------------------------------------------------------------
    module Light_Core
      Effects = { # Não mude isto!
    #-------------------------------------------------------------------------------
    # ADICIONE ABAIXO OS SEUS EFEITOS!
    #-------------------------------------------------------------------------------
      0 => ["light",255,0,false],
      1 => ["torch",200,20,false],
      2 => ["torch_m",180,30,false],
      3 => ["light_s",255,0,false],
     
    #-------------------------------------------------------------------------------
    # Fim da configuração de efeitos
    #-------------------------------------------------------------------------------
      } # Não mude isto!
     
      # Coordenada Z da superfície de efeitos:
      Surface_Z = 180
     
      # Habilitar controle da superfície por "Tonalidade da Tela"?
      Surface_UE = true
     
      # Tag para a superfície se comportar como "telhado"
      Roof_Tag = 5
      # Tag para a superfície se comportar como "parede"
      Wall_Tag = 6
      # Tag para a superfície se comportar como "bloco" (semelhante ao telhado)
      Block_Tag = 7
     
      # Constante de correção de ângulo (não altere)
      ACC = Math.tan(Math::PI/26)
    end
    #-------------------------------------------------------------------------------
    # Fim da configuração - Início do script
    #-------------------------------------------------------------------------------
    module Cache
      def self.light(filename)
        load_bitmap("Graphics/Lights/", filename)
      end
    end
    module Light_Bitcore
      include Light_Core
      def self.initialize
        @@buffer = {}
        Effects.values.each { |effect| Light_Bitcore.push(effect[0])}
      end
      def self::[](key)
        return @@buffer[key]
      end
      def self.push(key)
        return if @@buffer.keys.include?(key)
        @@buffer[key] = Cache.light(key)
      end
    end
    Light_Bitcore.initialize
    class Light_SSource
      attr_reader :real_x
      attr_reader :real_y
      attr_reader :range
      attr_accessor :bitmap
      attr_reader :w
      attr_reader :h
      attr_reader :hs
      def initialize(char,bitmap,opacity,plus,hs)
        sync(char)
        @key = bitmap
        @bitmap = Light_Bitcore[@key].clone
        @range = @bitmap.width/2
        @w = @bitmap.width
        @h = @bitmap.height
        @mr = @range - 16
        @opacity = opacity
        @plus = plus
        @hs = hs
        render if @hs
      end
      def render
        tx = x
        ty = y
        tsx = x + @range
        tsy = y + @range
        dr = @range*2
        for s in $game_map.surfaces
          next if !s.visible?(tsx,tsy) || !s.within?(tx,tx+dr,ty,ty+dr)
          s.render_shadow(tx,ty,tsx,tsy,@range,@bitmap)
        end
      end
      def restore
        return unless @bitmap.nil?
        @bitmap = Light_Bitcore[@key].clone
        render if @hs
      end
      def opacity
        @plus == 0 ? @opacity : (@opacity + rand(@plus))
      end
      def sx
        return $game_map.adjust_x(@real_x)*32-@mr
      end
      def sy
        return $game_map.adjust_y(@real_y)*32-@mr
      end
      def sync(char)
        @real_x = char.real_x
        @real_y = char.real_y
      end
      def x
        return (@real_x*32 - @mr).to_f
      end
      def y
        return (@real_y*32 - @mr).to_f
      end
      def dispose
        return if @bitmap.nil?
        @bitmap.dispose
        @bitmap = nil
      end
    end
    class Light_DSource < Light_SSource
      attr_reader :bitmap
      attr_reader :visible
      def initialize
        @key = nil
        @bitmap = nil
        @opacity = 255
        @plus = 0
        @char = $game_player
        @visible = false
      end
      def set_opacity(o,p)
        @opacity = o
        @plus = p
      end
      def set_graphic(sb)
        dispose
        @key = {2=>sb,4=>sb,6=>sb,8=>sb}
        Light_Bitcore.push(sb)
        @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
        @range = @bitmap[2].width/2
        @w = @bitmap[2].width
        @h = @bitmap[2].height
        @mr = @range - 16
      end
      def set_multiple_graphics(ba)
        dispose
        @key = ba
        @key.values.each {|key| Light_Bitcore.push(key)}
        @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
        @range = @bitmap[2].width/2
        @w = @bitmap[2].width
        @h = @bitmap[2].height
        @mr = @range - 16
      end
      def get_graphic
        return @bitmap[@char.direction].clone
      end
      def show
        return if @bitmap.nil?
        @visible = true
      end
      def hide
        @visible = false
      end
      def restore
        return if @key.nil?
        @key.values.each {|key| Light_Bitcore.push(key)}
        @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
      end
      def dispose
        return if @bitmap.nil?
        @bitmap.values.each { |b| b.dispose }
        @bitmap = nil
      end
      def change_owner(char)
        @char = char
      end
      def render
      end
      def sx
        return $game_map.adjust_x(@char.real_x)*32-@mr
      end
      def sy
        return $game_map.adjust_y(@char.real_y)*32-@mr
      end
      def x
        return (@char.real_x*32 - @mr).to_f
      end
      def y
        return (@char.real_y*32 - @mr).to_f
      end
    end
    class Light_Surface
      def initialize
        @ta = @a = 0
        @tr = @r = 255
        @tg = @g = 255
        @tb = @b = 255
        @va = @vr = @vg = @vb = 0.0
        @timer = 0
      end
      def refresh
        return if @timer == 0
        @a += @va
        @r += @vr
        @g += @vg
        @b += @vb
        $game_map.light_surface.opacity = @a
        @timer -= 1
      end
      def change_color(time,r,g,b,a=nil)
        r = 0 if r < 0; r = 255 if r > 255
        g = 0 if g < 0; g = 255 if g > 255
        b = 0 if b < 0; b = 255 if b > 255
        unless a.nil?
          a = 0 if a < 0; a = 255 if a > 255
        end
        @timer = time
        @tr = 255-r
        @tg = 255-g
        @tb = 255-b
        @va = (a.nil? ? 0 : (a-@a).to_f/@timer)
        @vr = (@tr - @r).to_f/@timer
        @vg = (@tg - @g).to_f/@timer
        @vb = (@tb - @b).to_f/@timer
      end
      def change_alpha(time,a)
        a = 0 if a < 0; a = 255 if a > 255
        @timer = time
        @ta = a
        @vr = @vg = @vb = 0.0
        @va = (a-@a).to_f/@timer
      end
      def set_color(r,g,b)
        r = 0 if r < 0; r = 255 if r > 255
        g = 0 if g < 0; g = 255 if g > 255
        b = 0 if b < 0; b = 255 if b > 255
        @tr = @r = 255-r
        @tg = @g = 255-g
        @tb = @b = 255-b
        @va = @vr = @vg = @vb = 0.0
        @timer = 0
      end
      def set_alpha(a)
        a = 0 if a < 0; a = 255 if a > 255
        @ta = @a = a
        $game_map.light_surface.opacity = @a
        @va = @vr = @vg = @vb = 0.0
        @timer = 0
      end
      def alpha
        return @a
      end
      def color
        return Color.new(@r,@g,@b)
      end
    end
    class Game_Map
      include Light_Core
      attr_accessor :light_surface
      attr_accessor :light_sources
      attr_accessor :surfaces
      attr_accessor :effect_surface
      attr_accessor :lantern
      alias kbl_setup_events setup_events
      alias kbl_initialize initialize
      alias kbl_update update
      def initialize
        kbl_initialize
        @effect_surface = Light_Surface.new
        @lantern = Light_DSource.new
      end
      def update(arg)
        @effect_surface.refresh if arg
        kbl_update(arg)
      end
      def first_tag(x,y)
        tag = tileset.flags[tile_id(x,y,0)] >> 12
        return tag > 0 ? tag : 0
      end
      def setup_events
        @light_sources.nil? ? @light_sources = [] : @light_sources.clear
        setup_surfaces
        merge_surfaces
        kbl_setup_events
      end
      def setup_surfaces
        @surfaces = []
        for x in 0..(width-1)
          for y in 0..(height-1)
            tag = first_tag(x,y)
            if tag == Wall_Tag
              i = tile_id(x,y,0)
              if i & 0x02 == 0x02
                @surfaces << Block_SD.new(x*32,y*32,x*32+32,y*32)
              end
              if i & 0x04 == 0x04
                @surfaces << Block_WR.new(x*32+31,y*32,x*32+31,y*32+32)
                @surfaces << Block_IL.new(x*32+32,y*32,x*32+32,y*32+32)
              end
              if i & 0x01 == 0x01
                @surfaces << Block_IR.new(x*32-1,y*32,x*32-1,y*32+32)
                @surfaces << Block_WL.new(x*32,y*32,x*32,y*32+32)
              end
            elsif tag == Roof_Tag
              i = tile_id(x,y,0)
              @surfaces << Block_SU.new(x*32,y*32,x*32+32,y*32) if i & 0x02 == 0x02
              @surfaces << Block_SR.new(x*32+31,y*32,x*32+31,y*32+32) if i & 0x04 == 0x04
              @surfaces << Block_SL.new(x*32,y*32,x*32,y*32+32) if i & 0x01 == 0x01
            elsif tag == Block_Tag
              f = tileset.flags[tile_id(x,y,0)]
              @surfaces << Block_SL.new(x*32,y*32,x*32,y*32+32) if f & 0x02 == 0x02
              @surfaces << Block_SR.new(x*32+31,y*32,x*32+31,y*32+32) if f & 0x04 == 0x04
              @surfaces << Block_SU.new(x*32,y*32,x*32+32,y*32) if f & 0x08 == 0x08
            end
          end
        end
      end
      def merge_surfaces
        new_surfaces = []
        hs = []; vs = []
        ws = []; is = []
        for surface in @surfaces
          if surface.type & 0x05 == 0
            hs << surface
          else
            if surface.type & 0x010 == 0
              vs << surface
            else
              if surface.type & 0x08 == 0
                ws << surface
              else
                is << surface
              end
            end
          end
        end
        for surface in hs
          surface.ready ? next : surface.ready = true
          for s in hs
            next if s.ready || s.y1 != surface.y1 || surface.type != s.type
            if s.x2 == surface.x1
              surface.x1 = s.x1
              s.trash = true
              s.ready = true
              surface.ready = false
            elsif s.x1 == surface.x2
              surface.x2 = s.x2
              s.trash = true
              s.ready = true
              surface.ready = false
            end
          end
        end
        hs.each { |s| @surfaces.delete(s) if s.trash}
        for surface in vs
          surface.ready ? next : surface.ready
          for s in vs
            next if s.ready || s.x1 != surface.x1
            if s.y2 == surface.y1
              surface.y1 = s.y1
              s.trash = true
              s.ready = true
              surface.ready = false
            elsif s.y1 == surface.y2
              surface.y2 = s.y2
              s.trash = true
              s.ready = true
              surface.ready = false
            end
          end
        end
        vs.each { |s| @surfaces.delete(s) if s.trash}
        for surface in ws
          surface.ready ? next : surface.ready
          for s in ws
            next if s.ready || s.x1 != surface.x1
            if s.y2 == surface.y1
              surface.y1 = s.y1
              s.trash = true
              s.ready = true
              surface.ready = false
            elsif s.y1 == surface.y2
              surface.y2 = s.y2
              s.trash = true
              s.ready = true
              surface.ready = false
            end
          end
        end
        ws.each { |s| @surfaces.delete(s) if s.trash}
        for surface in is
          surface.ready ? next : surface.ready
          for s in is
            next if s.ready || s.x1 != surface.x1
            if s.y2 == surface.y1
              surface.y1 = s.y1
              s.trash = true
              s.ready = true
              surface.ready = false
            elsif s.y1 == surface.y2
              surface.y2 = s.y2
              s.trash = true
              s.ready = true
              surface.ready = false
            end
          end
        end
        is.each { |s| @surfaces.delete(s) if s.trash}
      end
    end
    class Game_Event < Game_Character
      alias kbl_initialize initialize
      alias kbl_setup_page setup_page
      def initialize(m,e)
        @light = nil
        kbl_initialize(m,e)
      end
      def setup_page(np)
        kbl_setup_page(np)
        setup_light(np.nil?)
      end
      def setup_light(dispose)
        unless @light.nil?
          $game_map.light_sources.delete(self)
          @light.dispose
          @light = nil
        end
        unless dispose && @list.nil?
          for command in @list
            if command.code == 108 && command.parameters[0].include?("[light")
              command.parameters[0].scan(/\[light ([0.0-9.9]+)\]/)
              effect = Light_Core::Effects[$1.to_i]
              @light = Light_SSource.new(self,effect[0],effect[1],effect[2],effect[3])
              $game_map.light_sources << self
              return
            end
          end
        end
      end
      def draw_light
        sx = @light.sx
        sy = @light.sy
        w = @light.w
        h = @light.h
        return if sx > 544 && sy > 416 && sx + w < 0 && sy + h < 0
        $game_map.light_surface.bitmap.blt(sx,sy,@light.bitmap,Rect.new(0,0,w,h),@light.opacity)
      end
      def dispose_light
        @light.dispose
      end
      def restore_light
        @light.restore
      end
    end
    if Light_Core::Surface_UE
      class Game_Interpreter
        def command_223
          $game_map.effect_surface.change_color(@params[1],@params[0].red,@params[0].green,@params[0].blue,@params[0].gray)
          wait(@params[1]) if @params[2]
        end
      end
    end
    class Game_Interpreter
      def self_event
        return $game_map.events[@event_id]
      end
    end
    class Block_Surface
      include Light_Core
      attr_accessor :x1
      attr_accessor :y1
      attr_accessor :x2
      attr_accessor :y2
      attr_accessor :ready
      attr_accessor :trash
      def initialize(x1,y1,x2,y2)
        @x1 = x1
        @y1 = y1
        @x2 = x2
        @y2 = y2
        @ready = false
        @trash = false
      end
      def within?(min_x,max_x,min_y,max_y)
        return @x2 > min_x && @x1 < max_x && @y2 > min_y && @y1 < max_y
      end
    end
    class Block_SL < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x01
      end
      def visible?(sx,sy)
        return sx < @x1
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        @m1 = (@y1-sy)/(@x1-sx)
        @n1 = sy - @m1*sx
        @m2 = (@y2-sy)/(@x2-sx)
        @n2 = sy - @m2*sx
        for x in @x1..(sx+range)
          init = shadow_iy(x)
          bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+3)
        end
      end
      def shadow_iy(x)
        return @m1*x+@n1
      end
      def shadow_fy(x)
        return @m2*x+@n2
      end
    end
    class Block_SR < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x04
      end
      def visible?(sx,sy)
        return sx > @x1
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        @m1 = (@y1-sy)/(@x1-sx)
        @n1 = sy - @m1*sx
        @m2 = (@y2-sy)/(@x2-sx)
        @n2 = sy - @m2*sx
        for x in (sx-range).to_i..@x1
          init = shadow_iy(x)
          bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+3)
        end
      end
      def shadow_iy(x)
        return @m1*x+@n1
      end
      def shadow_fy(x)
        return @m2*x+@n2
      end
    end
    class Block_IL < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x019
      end
      def visible?(sx,sy)
        return sx < @x1 && sy > @y1
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        @m1 = (@y1-sy)/(@x1-sx)
        @n1 = @y1 - @m1*@x1
        @m2 = (@y2-sy)/(@x2-sx)
        @m2 = 0 if @m2 > 0
        @n2 = @y2 - @m2*@x2
        for x in @x1..(sx+range)
          init = shadow_iy(x).floor
          bitmap.clear_rect(x-phx,init-3-phy,1,shadow_fy(x)-init+3)
        end
      end
      def shadow_iy(x)
        return @m1*x+@n1
      end
      def shadow_fy(x)
        return @m2*x+@n2
      end
    end
    class Block_IR < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x01c
      end
      def visible?(sx,sy)
        return sx > @x1 && sy > @y1
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        @m1 = (@y1-sy)/(@x1-sx)
        @n1 = @y1 - @m1*@x1
        @m2 = (@y2-sy)/(@x2-sx)
        @m2 = 0 if @m2 < 0
        @n2 = @y2 - @m2*@x2
        for x in (sx-range).to_i..@x1
          init = shadow_iy(x).floor
          bitmap.clear_rect(x-phx,init-3-phy,1,shadow_fy(x)-init+3)
        end
      end
      def shadow_iy(x)
        return @m1*x+@n1
      end
      def shadow_fy(x)
        return @m2*x+@n2
      end
    end
    class Block_WL < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x011
      end
      def visible?(sx,sy)
        return sx < @x1 && sy < @y2
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        @m1 = (@y1-sy)/(@x1-sx)
        @n1 = sy - @m1*sx
        @m2 = (@y2-sy)/(@x2-sx)
        @n2 = sy - @m2*sx
        for x in @x1..(sx+range)
          init = shadow_iy(x)
          bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+2)
        end
      end
      def shadow_iy(x)
        return @m1*x+@n1
      end
      def shadow_fy(x)
        return @m2*x+@n2
      end
    end
    class Block_WR < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x014
      end
      def visible?(sx,sy)
        return sx > @x1 && sy < @y2
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        @m1 = (@y1-sy)/(@x1-sx)
        @n1 = sy - @m1*sx
        @m2 = (@y2-sy)/(@x2-sx)
        @n2 = sy - @m2*sx
        for x in (sx-range).to_i..@x1
          init = shadow_iy(x)
          bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+2)
        end
      end
      def shadow_iy(x)
        return @m1*x+@n1
      end
      def shadow_fy(x)
        return @m2*x+@n2
      end
    end
    class Block_SU < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x02
      end
      def visible?(sx,sy)
        return sy < @y1
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        if @x1 == sx
          @m1 = nil
        else
          @m1 = (@y1-sy)/(@x1-sx)
          @m1 += ACC if @m1 < -ACC
          @n1 = @y1 - @m1*@x1
        end
        if @x2 == sx
          @m2 = nil
        else
          @m2 = (@y2-sy)/(@x2-sx)
          @n2 = sy - @m2*sx
        end
        for y in @y1..(sy+range)
          init = shadow_ix(y)
          bitmap.clear_rect(init-phx,y-phy,shadow_fx(y)-init+1,1)
        end
      end
      def shadow_ix(y)
        return @m1.nil? ? @x1 : (y-@n1)/@m1
      end
      def shadow_fx(y)
        return @m2.nil? ? @x2 : (y-@n2)/@m2
      end
    end
    class Block_SD < Block_Surface
      attr_reader :type
      def initialize(x1,y1,x2,y2)
        super(x1,y1,x2,y2)
        @type = 0x08
      end
      def visible?(sx,sy)
        return sy > @y1
      end
      def render_shadow(phx,phy,sx,sy,range,bitmap)
        if @x1 == sx
          @m1 = nil
        else
          @m1 = (@y1-sy)/(@x1-sx)
          @m1 -= ACC if @m1 > ACC
          @n1 = sy - @m1*sx
        end
        if x2 == sx
          @m2 = nil
        else
          @m2 = (@y2-sy)/(@x2-sx)
          @n2 = sy - @m2*sx
        end
        for y in (sy-range).to_i..@y1
          init = shadow_ix(y)
          bitmap.clear_rect(init-phx,y-phy,shadow_fx(y)-init+1,1)
        end
      end
      def shadow_ix(y)
        return @m1.nil? ? @x1 : (y-@n1)/@m1
      end
      def shadow_fx(y)
        return @m2.nil? ? @x2 : (y-@n2)/@m2
      end
    end
    class Spriteset_Map
      include Light_Core
      alias kbl_initialize initialize
      alias kbl_update update
      alias kbl_dispose dispose
      def initialize
        setup_lights
        kbl_initialize
      end
      def update
        kbl_update
        update_lights
      end
      def dispose
        kbl_dispose
        dispose_lights
      end
      def dispose_lights
        $game_map.lantern.dispose
        $game_map.light_sources.each { |source| source.dispose_light }
        $game_map.light_surface.bitmap.dispose
        $game_map.light_surface.dispose
        $game_map.light_surface = nil
      end
      def update_lights
        $game_map.light_surface.bitmap.clear
        $game_map.light_surface.bitmap.fill_rect(0,0,544,416,$game_map.effect_surface.color)
        $game_map.light_sources.each { |source| source.draw_light }
        return unless $game_map.lantern.visible
        @btr = $game_map.lantern.get_graphic
        x = $game_map.lantern.x
        y = $game_map.lantern.y
        r = $game_map.lantern.range
        sx = x + r
        sy = y + r
        dr = r*2
        $game_map.surfaces.each { |s| s.render_shadow(x,y,sx,sy,r,@btr) if s.visible?(sx,sy) && s.within?(x,x+dr,y,y+dr) }
        $game_map.light_surface.bitmap.blt($game_map.lantern.sx,$game_map.lantern.sy,@btr,Rect.new(0,0,dr,dr),$game_map.lantern.opacity)
      end
      def setup_lights
        @btr = nil
        $game_map.lantern.restore
        $game_map.light_sources.each { |source| source.restore_light }
        $game_map.light_surface = Sprite.new
        $game_map.light_surface.bitmap = Bitmap.new(544,416)
        $game_map.light_surface.bitmap.fill_rect(0,0,544,416,$game_map.effect_surface.color)
        $game_map.light_surface.blend_type = 2
        $game_map.light_surface.opacity = $game_map.effect_surface.alpha
        $game_map.light_surface.z = Surface_Z
      end
    end
    LeonM²
    LeonM²
    Moderador Local
    Moderador Local

    Mensagens : 1790
    Créditos : 139
    Cash : 0

    [AJUDA] Khas Effect no VXA-OS Empty Re: [AJUDA] Khas Effect no VXA-OS

    Mensagem por LeonM² em Dom Ago 04, 2019 3:11 pm

    No script troca todos os 544 por Graphics.width e todos os 416 por Graphics.height, deve resolver.


    _________________
    Caso precise de suporte para algum dos meus scripts, me adicione no Discord: LeonM²#9597
    Haseo
    Haseo
    Ocasional
    Ocasional

    Mensagens : 167
    Créditos : 4
    Cash : 0

    [AJUDA] Khas Effect no VXA-OS Empty Re: [AJUDA] Khas Effect no VXA-OS

    Mensagem por Haseo em Dom Ago 04, 2019 3:55 pm

    Valeu mano. Muito obrigado <3

    Conteúdo patrocinado

    [AJUDA] Khas Effect no VXA-OS Empty Re: [AJUDA] Khas Effect no VXA-OS

    Mensagem por Conteúdo patrocinado


      Data/hora atual: Ter Out 15, 2019 10:29 am