Procuro uma equipe para ajudar no meu projeto Horror Game

[Miilordz]

Estou com um projeto, para fazer um game de Terror pelo RPG MAKER Vx ace.
Ainda sou Iniciante na parte de RPG Maker mas escrevo livros e sou um roteirista com experiencia em games e também em alguns livros. Tenho um tempo consideravel e esse seria meu primeiro jogo, quero alguem que me ajude com os mapas, herois e preciso fazer algumas arts.
Planejo fazer esse game de maneira que os personagens tenham laços e planejo também fazer com que o jogador tenha afeição por eles, esse projeto é para pessoas que querem algo no estilo Survivor Horror. Algo dificil de se fazer... A atmosfera, a construção dos personagens, puzzles, cutscenes, vilões e etc.

Por favor, quem estiver interessado no processo fale por aqui e me adicione no facebook depois mande uma mensagem.
Mais uma coisa, quero pessoas que tenham ao menos 2 ou 3 horas para dedicar ao trabalho, que mantenha contato sempre se possivel. Por whats, face, tanto faz... E tudo obrigado"

[Iroe]

Estou com um projeto, para fazer um game de Terror pelo RPG MAKER Vx ace.
Ainda sou Iniciante na parte de RPG Maker mas escrevo livros e sou um roteirista com experiencia em games e também em alguns livros. Tenho um tempo consideravel e esse seria meu primeiro jogo, quero alguem que me ajude com os mapas, herois e preciso fazer algumas arts.
Planejo fazer esse game de maneira que os personagens tenham laços e planejo também fazer com que o jogador tenha afeição por eles, esse projeto é para pessoas que querem algo no estilo Survivor Horror. Algo dificil de se fazer... A atmosfera, a construção dos personagens, puzzles, cutscenes, vilões e etc.

Por favor, quem estiver interessado no processo fale por aqui e me adicione no facebook depois mande uma mensagem.
Mais uma coisa, quero pessoas que tenham ao menos 2 ou 3 horas para dedicar ao trabalho, que mantenha contato sempre se possivel. Por whats, face, tanto faz... E tudo obrigado"

Cara, não vou poder te ajudar, mas... este script vai te ajudar muito. Foi feito pelo Khas e, seu nome é Khas Awesome Lights Effects:

#-------------------------------------------------------------------------------
# * [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,true],
  1 => ["torch",200,20,true],
  2 => ["torch_m",180,30,true],
  3 => ["light_s",255,0,true],
  
#-------------------------------------------------------------------------------
# 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