#==============================================================================
# ** Load_Screen
# Por El_Dison
#==============================================================================

=begin Este script cria uma tela de loading que pode ser usada na tela de save, load
 e ao mudar de mapa.

 Para chamar a tela de loading ao mudar de mapa, deve-se usar o chamar script
 com o código "$scene = Load_Screen.new(0, [id do mapa, posição x, posição y])"
 id do mapa = id do mapa para onde será teleportado (o id do mapa aparece na barra de status)
 posição x = posição horizontal para onde o herói será teleportado
 posição y = posição vertical para onde o herói será teleportado

 Se quiser chamar a tela de loading antes de uma outra scene basta usar o comando
 "$scene = Load_Screen.new(3, [nome da scene])" onde o nome da scene é a scene
 que será chamada após a tela de loading. Ex.: "$scene = Load_Screen.new(3, [Scene_Menu])"
 no exemplo, a barra será chamada antes do menu. Para não ter que usar o chamar
 script, basta substituir o comando do editor de scripts como foi feito no main
 para a tela ser exibida antes da tela de título.

 Configuações para exibição abaixo
==============================================================================
=end
module Load_Screen
  #--------------------------------------------------------------------------
  # * CONFIGURAÇÕES GERAIS
  #--------------------------------------------------------------------------

  # Tempo de duração da tela de loading (em segundos)
  Time_Sec = 3
  
  # Som executado ao completar o tempo de espera
  Load_Sound = "008-System08"

  # Deseja ativar a tela de load ao salvar jogo?
  Enable_Save = true # true para ativar e false para desativar

  # Deseja ativar a tela de load ao carregar jogo?
  Enable_Load = true # true para ativar e false para desativar
  
  #--------------------------------------------------------------------------
  # * CONFIGURAÇÕES DA IMAGEM
  #--------------------------------------------------------------------------

  # Definir o modo de exibição da imagem
  Picture_Style = 1
  # 0 = Nenhuma imagem será exibida no menu
  # 1 = Cada menu terá uma imagem (ou um grupo) específica
  # 2 = Imagens aleatorias sempre que chamar a scene

  # Nome das imagens de cada menu (tem efeito apenas se Picture_Style = 1)
  # Caso coloque mais de uma imagem, será escolhida uma aleatoriamente a cada vez
  Picture_Save = ["Lannister"] # Imagem(s) exibida(s) ao salvar (não retire os colchetes)
  Picture_Load = ["Baratheon"] # Imagem(s) exibida(s) ao carregar (não retire os colchetes)
  Picture_Map = ["Westeros_and_Essos"] # Imagem(s) exibida(s) ao mudar de mapa (não retire os colchetes)
  Picture_Scene = ["Iron Throne"] # Imagem(s) exibida(s) ao chamar a scene antes de uma outra
  
  # Nome da imagem de fundo (tem efeito apenas se Picture_Style = 2)
  # O nome das imagens devem estar entre aspas e separados por virgula
  Randon_Picture = ["Stark", "Baratheon", "Lannister"] # Não retire os colchetes

  #--------------------------------------------------------------------------
  # * CONFIGURAÇÕES DA MENSAGEM
  #--------------------------------------------------------------------------

  # Deseja exibir uma mensagem dentro da barra 
  Show_Message = true # true para ativar e false para desativar
  
  # As opções abaixo só terão efeito caso Show_Message = true

  # Deseja que a mensagem seja exibida em italico?
  Message_Italic = true # true para ativar e false para desativar
  
  # Deseja que a mensagem seja exibida em negrito?
  Message_Bold = true # true para ativar e false para desativar
  
  # Mensagem de mudança de mapas
  Map_Message = "Carregando mapa..."
  
  # Mensagem da tela de save
  Save_Message = "Salvando jogo, aguarde..."
  
  # Mensagem da tela de load
  Load_Message = "Carregando jogo, aguarde..."
  
  # Mensagem que aparece quando o  tempo de loading se completa
  Message_Loaded = "Pressione enter para continuar"
  
  # Cor da mensagem
  Message_Color = Color.new(0, 0, 0) # (vermelho, verde, azul)
  # Exemplos de cores:
  # Vermelho = (255, 0, 0)
  # Verde = (0, 255, 0)
  # Azul = (0, 0, 255)
  
  # Tamanho da fonte da mensagem
  Font_Size = 20 # Deve ser um tamanho inferior ao tamanho da imagem

  #--------------------------------------------------------------------------
  # * CONFIGURAÇÕES DA BARRA DE TEMPO
  #--------------------------------------------------------------------------

  # Deseja exibir a barra de tempo
  Show_Bar = true # true para ativar e false para desativar

  # Nome da imagem da barra vazia
  Back_Pic = "Back"
  
  # Nome da imagem da barra cheia (Deve ter o mesmo tamanho da Back_Pic)
  Bar_Pic = "Bar"
  
  # Posisão da barra [x, y]
  Bar_Position = [160, 352]
  
  #--------------------------------------------------------------------------
  # * Não altere essas linhas
  #--------------------------------------------------------------------------
  Time_Load = Time_Sec * 40
  Message_Load = [Map_Message, Save_Message, Load_Message]
  Fix_Picture = [Picture_Map, Picture_Save, Picture_Load, Picture_Scene]
end

#==============================================================================
# ** Window_Load
#==============================================================================

class Window_Load < Window_Base
  include Load_Screen
  #--------------------------------------------------------------------------
  # * Variáveis
  #--------------------------------------------------------------------------
  attr_accessor:time
  attr_accessor:message
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(type)
    super(0, 0, 640, 480)
    self.contents = Bitmap.new(width - 32,height - 32)
    self.opacity = 0
    self.back_opacity = 0
    @time = 0
    @message = type
    refresh
  end
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    create_bar if Show_Bar == true
    create_message if Show_Message == true
  end
  #--------------------------------------------------------------------------
  # * Criação da barra de carregamento
  #--------------------------------------------------------------------------
  def create_bar
    # Criar fundo da barra
    @back_image = RPG::Cache.picture(Back_Pic)
    self.contents.blt(Bar_Position[0], Bar_Position[1], @back_image, @back_image.rect)
    # Criar barra de carregamento
    @bar_image = RPG::Cache.picture(Bar_Pic)
    rect = Rect.new(0, 0, @bar_image.width * @time.to_i/Time_Load, @bar_image.height)
    self.contents.blt(Bar_Position[0], Bar_Position[1], @bar_image, rect)
  end
  #--------------------------------------------------------------------------
  # * Criação da mensagem
  #--------------------------------------------------------------------------
  def create_message
    self.contents.font.color = Message_Color
    self.contents.font.size = Font_Size
    self.contents.font.bold =  Message_Bold
    self.contents.font.italic = Message_Italic
    if Show_Bar == true
      width = @back_image.width
      height = @back_image.height
    else
      width = contents.text_size(@message).width
      height = contents.text_size(@message).height
    end
    self.contents.draw_text(Bar_Position[0], Bar_Position[1], width, height, @message, 1)
  end
end

#==============================================================================
# ** Scene_Load_Screen
#==============================================================================

class Scene_Load_Screen
  include Load_Screen
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize(type = 0, data = nil, scene = nil)
    @type = type
    @data = data
    @scene_call = scene
    @time = 0
    @type == 3 ? @message = data.to_s : @message = Message_Load[@type]
  end
  #--------------------------------------------------------------------------
  # * Processo principal
  #--------------------------------------------------------------------------
  def main
    start
    perform_transition
    Input.update
    loop do
      Graphics.update
      Input.update
      update
      break if $scene != self
    end
    Graphics.update
    Graphics.freeze
    terminate
  end
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    create_system if @scene_call == Scene_Title
    create_sprite if Picture_Style != nil
    create_bar_window if Show_Bar == true || Show_Message == true
  end
  #--------------------------------------------------------------------------
  # * Execução da transição
  #--------------------------------------------------------------------------
  def perform_transition
    Graphics.transition(10)
  end
  #--------------------------------------------------------------------------
  # * Fim do processo
  #--------------------------------------------------------------------------
  def terminate
    @sprite.dispose and @sprite.bitmap.dispose if @sprite != nil
    @load_window.dispose if @load_window != nil
  end
  #--------------------------------------------------------------------------
  # * Criação do sistema caso chamado antes da scene_title
  #--------------------------------------------------------------------------
  def create_system
    $data_system = load_data("Data/System.rxdata")
    $game_system = Game_System.new
  end
  #--------------------------------------------------------------------------
  # * Criação da imagem de fundo
  #--------------------------------------------------------------------------
  def create_sprite
    Picture_Style == 1 ? @picture_show = Fix_Picture[@type] : @picture_show = Randon_Picture
    @sprite = Sprite.new
    @sprite.bitmap = RPG::Cache.picture(@picture_show[rand(@picture_show.size)])
  end
  #--------------------------------------------------------------------------
  # * Criação da janela de carregamento/menssagem
  #--------------------------------------------------------------------------
  def create_bar_window
    @load_window = Window_Load.new(@message)
  end
  #--------------------------------------------------------------------------
  # * Atualização da tela
  #--------------------------------------------------------------------------
  def update
    @time += 1 if @time <= Time_Load + 5
    if @load_window != nil
      @load_window.time = @time
      @load_window.message = @message
      @load_window.refresh
    end
    if @time >= Time_Load
      Audio.se_play("Audio/SE/" + Load_Sound, 100, 100) if @time == Time_Load
      @message = Message_Loaded
      # Se o botão C for pressionado
      if Input.trigger?(Input::C)
        case @type
        when 0
          command_map
        when 1
          command_save
        when 2
          command_load
        when 3
          command_scene
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Comando [Teleporte]
  #--------------------------------------------------------------------------
  def command_map
    $game_map.setup(@data[0])
    $game_player.moveto(@data[1], @data[2])
    $game_player.refresh
    $game_map.autoplay
    $game_map.update
    # Alternar para o mapa
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Comando [Salvar]
  #--------------------------------------------------------------------------
  def command_save
    # Reproduzir SE de OK
    $game_system.se_play($data_system.decision_se)
    # Alternar para a tela do Menu
    $scene = Scene_Menu.new(4)
  end
  #--------------------------------------------------------------------------
  # * Comando [Carregar]
  #--------------------------------------------------------------------------
  def command_load
    # Reproduzir SE de OK
    $game_system.se_play($data_system.decision_se)
    # Alternar para o mapa
    $scene = Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Comando [Scene]
  #--------------------------------------------------------------------------
  def command_scene
    # Reproduzir SE de OK
    $game_system.se_play($data_system.decision_se)
    # Alternar para o mapa
    $scene = @scene_call.new
  end
end

#=============================================================================
# ** Scene Save
#=============================================================================

class Scene_Save < Scene_File
  include Load_Screen
  #--------------------------------------------------------------------------
  # * on_decision
  #--------------------------------------------------------------------------
  if Enable_Save == true
    alias save_screen_on_decision on_decision 
    def on_decision(filename)
      save_screen_on_decision(filename)
      $scene = Scene_Load_Screen.new(1)
    end
  end
end  

#=============================================================================
# ** Scene Load
#=============================================================================

class Scene_Load < Scene_File  
  include Load_Screen
  #--------------------------------------------------------------------------
  # * on_decision
  #--------------------------------------------------------------------------    
  if Enable_Load == true
    alias load_screen_on_decision on_decision 
    def on_decision(filename)
      load_screen_on_decision(filename)
      if FileTest.exist?(filename)
        $scene = Scene_Load_Screen.new(2)
      end
    end
  end
end