Chaos Project

#==============================================================================
# Scene_Menu
#------------------------------------------------------------------------------
# Esta classe processa a Tela de Menu
#==============================================================================

class Scene_Menu
  
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #
  #     menu_index : posição inicial do cursor de comando
  #--------------------------------------------------------------------------
  
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end
  
  #--------------------------------------------------------------------------
  # Processamento Principal
  #--------------------------------------------------------------------------
  
  def main
    # Criar janela de comando
    s1 = $data_system.words.item
    s2 = $data_system.words.equip
    s3 = "Save"
    s4 = "Exit"
    @command_window = Window_Command.new(160, [s1, s2, s3, s4])
    @command_window.index = @menu_index
    # Se o número de membros do Grupo de Heróis for 0
    if $game_party.actors.size == 0
      # Desabilar as janelas de Item, Habilidades, Equipamento e Status
      @command_window.disable_item(0)
      @command_window.disable_item(2)
    end
    # Se Salvar for Proibido
    if $game_system.save_disabled
      # Desabilitar Salvar
      @command_window.disable_item(4)
    end
    # Criar janela de Tempo de Jogo
    @playtime_window = Window_PlayTime.new
    @playtime_window.x = 0
    @playtime_window.y = 224
    # Criar janela de Número Passos
    @steps_window = Window_Steps.new
    @steps_window.x = 0
    @steps_window.y = 320
    # Criar janela de Dinheiro
    @gold_window = Window_Gold.new
    @gold_window.x = 0
    @gold_window.y = 416
    # Criar janela de Status
    @status_window = Window_MenuStatus.new
    @status_window.x = 160
    @status_window.y = 0
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar Frame
      update
      # Abortar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para transiçõa
    Graphics.freeze
    # Exibição das janelas
    @command_window.dispose
    @playtime_window.dispose
    @steps_window.dispose
    @gold_window.dispose
    @status_window.dispose
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  
  def update
    # Atualizar janelas
    @command_window.update
    @playtime_window.update
    @steps_window.update
    @gold_window.update
    @status_window.update
    # Se a janela de comandos estiver ativo: chamar update_command
    if @command_window.active
      update_command
      return
    end
    # Se a janela de Status estiver ativa: call update_status
    if @status_window.active
      update_status
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame (Quando a janela de Comandos estiver Ativa)
  #--------------------------------------------------------------------------
  
  def update_command
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela do mapa
      $scene = Scene_Map.new
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Se o comando for outro senão Salvar, Fim de Jogo e o número de Heróis no
      # Grupo for 0
      if $game_party.actors.size == 0 and @command_window.index < 4
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Ramificação por posição do cursor na janela de comandos
      case @command_window.index
      when 0  # Items
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Itens
        $scene = Scene_Item.new
      when 1  # Equip
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Ativar o status da janela
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 2  # Save
        # Se Salvar for proibido
        if $game_system.save_disabled
          # Reproduzir SE de erro
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de save
        $scene = Scene_Save.new
      when 3  # Exit
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Fim de Jogo
        $scene = Scene_End.new
      end
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame (Quando o status da Janela estiver Ativo)
  #--------------------------------------------------------------------------
  
  def update_status
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Torna a janela de comandos ativa
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Ramificação por posição do cursor na janela de comandos
      case @command_window.index
      when 1  # Equipamento
        # Reproduzir SE de OK
        $game_system.se_play($data_system.decision_se)
        # Alternar para a tela de Equipamento
        $scene = Scene_Equip.new(@status_window.index)
      end
      return
    end
  end
end

#==============================================================================
# Scene_Equip
#------------------------------------------------------------------------------
# Esta classe processa a tela de Equipamento
#==============================================================================

class Scene_Equip
  
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #
  #     actor_index : Índice de Heróis
  #     equip_index : Índice de Equipamentos
  #--------------------------------------------------------------------------
  
  def initialize(actor_index = 0, equip_index = 0)
    @actor_index = actor_index
    @equip_index = equip_index
  end
  
  #--------------------------------------------------------------------------
  # Processamento Principal
  #--------------------------------------------------------------------------
  
  def main
    # Selecionar Herói
    @actor = $game_party.actors[@actor_index]
    # Criar janelas
    @help_window = Window_Help.new
    @left_window = Window_EquipLeft.new(@actor)
    @right_window = Window_EquipRight.new(@actor)
    @item_window1 = Window_EquipItem.new(@actor, 0)
    @item_window2 = Window_EquipItem.new(@actor, 1)
    @item_window3 = Window_EquipItem.new(@actor, 2)
    @item_window4 = Window_EquipItem.new(@actor, 3)
    @item_window5 = Window_EquipItem.new(@actor, 4)
    # Associar a janela de ajuda
    @right_window.help_window = @help_window
    @item_window1.help_window = @help_window
    @item_window2.help_window = @help_window
    @item_window3.help_window = @help_window
    @item_window4.help_window = @help_window
    @item_window5.help_window = @help_window
    # Definir a posição do cursor
    @right_window.index = @equip_index
    refresh
    # Executar transição
    Graphics.transition
    # Loop principal
    loop do
      # Atualizar a tela de jogo
      Graphics.update
      # Atualizar a entrada de informações
      Input.update
      # Atualizar o frame
      update
      # Abortar loop se a tela for alterada
      if $scene != self
        break
      end
    end
    # Preparar para a transição
    Graphics.freeze
    # Exibição das janelas
    @help_window.dispose
    @left_window.dispose
    @right_window.dispose
    @item_window1.dispose
    @item_window2.dispose
    @item_window3.dispose
    @item_window4.dispose
    @item_window5.dispose
  end
  
  #--------------------------------------------------------------------------
  # Atualizar
  #--------------------------------------------------------------------------
  
  def refresh
    # Definir a janela de Itens como visível
    @item_window1.visible = (@right_window.index == 0)
    @item_window2.visible = (@right_window.index == 1)
    @item_window3.visible = (@right_window.index == 2)
    @item_window4.visible = (@right_window.index == 3)
    @item_window5.visible = (@right_window.index == 4)
    # Selecionar os ´tens equipados atualmente
    item1 = @right_window.item
    # Set current item window to @item_window
    case @right_window.index
    when 0
      @item_window = @item_window1
    when 1
      @item_window = @item_window2
    when 2
      @item_window = @item_window3
    when 3
      @item_window = @item_window4
    when 4
      @item_window = @item_window5
    end
    # Se a janela da direita estiver ativa
    if @right_window.active
      # Limpar parâmetros para depois fazer a troca de equipamentos
      @left_window.set_new_parameters(nil, nil, nil)
    end
    # Se a janela de Itens estiver ativa
    if @item_window.active
      # Selecionar o Item escolhido
      item2 = @item_window.item
      # Mudar Equipamento
      last_hp = @actor.hp
      last_sp = @actor.sp
      @actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
      # Selecionar parâmetros para depois fazer a troca de equipamentos
      new_atk = @actor.atk
      new_pdef = @actor.pdef
      new_mdef = @actor.mdef
      # Retornar equipamento
      @actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
      @actor.hp = last_hp
      @actor.sp = last_sp
      # Desenhar na janela da esquerda
      @left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
    end
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  
  def update
    # Atualizar janelas
    @left_window.update
    @right_window.update
    @item_window.update
    refresh
    # Se a janela da direita estiver ativa: chamar update_right
    if @right_window.active
      update_right
      return
    end
    # Se a janela de Itens estiver ativa: chamar update_item
    if @item_window.active
      update_item
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame (Quando a janela da direita estiver Ativa)
  #--------------------------------------------------------------------------
  
  def update_right
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela de Menu
      $scene = Scene_Menu.new(1)
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Se o equipamento for fixo
      if @actor.equip_fix?(@right_window.index)
        # Reproduzir SE de erro
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Reproduzir SE de OK
      $game_system.se_play($data_system.decision_se)
      # Ativar janela de Itens
      @right_window.active = false
      @item_window.active = true
      @item_window.index = 0
      return
    end
    # Se o botão R for pressionado
    if Input.trigger?(Input::R)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O cursor se move para o próximo Herói
      @actor_index += 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de equipamento diferente
      $scene = Scene_Equip.new(@actor_index, @right_window.index)
      return
    end
    # Se o botão L for precionado
    if Input.trigger?(Input::L)
      # Reproduzir SE de cursor
      $game_system.se_play($data_system.cursor_se)
      # O cursor se move para o Herói anterior
      @actor_index += $game_party.actors.size - 1
      @actor_index %= $game_party.actors.size
      # Alternar para uma tela de equipamento diferente
      $scene = Scene_Equip.new(@actor_index, @right_window.index)
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame (Quando a janela de Itens estiver Ativa)
  #--------------------------------------------------------------------------
  
  def update_item
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Ativar janela da direita
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Reproduzir SE de Equipamento
      $game_system.se_play($data_system.equip_se)
      # Selecionar dados escolhidos na janela de Item
      item = @item_window.item
      # Mudar Equipamento
      @actor.equip(@right_window.index, item == nil ? 0 : item.id)
      # Ativar janela da direita
      @right_window.active = true
      @item_window.active = false
      @item_window.index = -1
      # Recriar os conteúdos da janela de Itens e da direita
      @right_window.refresh
      @item_window.refresh
      return
    end
  end
end

#==============================================================================
# Scene_Save
#------------------------------------------------------------------------------
# Esta classe processa o Save
#==============================================================================

class Scene_Save < Scene_File
  
  #--------------------------------------------------------------------------
  # Inicialização dos Objetos
  #--------------------------------------------------------------------------
  
  def initialize
    super("Em qual lugar você gostaria de salvar?")
  end
  
  #--------------------------------------------------------------------------
  # Processamento de Decisão
  #--------------------------------------------------------------------------
  
  def on_decision(filename)
    # Reproduzir Se de Save
    $game_system.se_play($data_system.save_se)
    # Graavar
    file = File.open(filename, "wb")
    write_save_data(file)
    file.close
    # Caso tenha sido chamdo por um evento...
    if $game_temp.save_calling
      # Limpar flag de chamado de save
      $game_temp.save_calling = false
      # Mudar para a tela do Mapa
      $scene = Scene_Map.new
      return
    end
    # Mudar para a tela do Menu
    $scene = Scene_Menu.new(2)
  end
  
  #--------------------------------------------------------------------------
  # Processo de Cancelamento
  #--------------------------------------------------------------------------
  
  def on_cancel
    # Reproduzir SE de cancelamento
    $game_system.se_play($data_system.cancel_se)
    # Caso tenha sido chamdo por um evento...
    if $game_temp.save_calling
      # Limpar flag de chamado de save
      $game_temp.save_calling = false
      # Mudar para a tela do Mapa
      $scene = Scene_Map.new
      return
    end
    # Mudar para a tela do Menu
    $scene = Scene_Menu.new(2)
  end
  
  #--------------------------------------------------------------------------
  # Gravando
  #     file : Gravando um arquivo
  #--------------------------------------------------------------------------
  
  def write_save_data(file)
    # Criar desenho dos Heróis para salvar
    characters = []
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      characters.push([actor.character_name, actor.character_hue])
    end
    # Gravar desenho dos Heróis para salvar
    Marshal.dump(characters, file)
    # Gravar contador de Tempo de Jogo
    Marshal.dump(Graphics.frame_count, file)
    # Acrescentar 1 em contador de saves
    $game_system.save_count += 1
    # Salvar número da Magia
    # Um número aleatório será selecionado cada vez que você salvar
    $game_system.magic_number = $data_system.magic_number
    # Gravar cada tipo de objeto do jogo
    Marshal.dump($game_system, file)
    Marshal.dump($game_switches, file)
    Marshal.dump($game_variables, file)
    Marshal.dump($game_self_switches, file)
    Marshal.dump($game_screen, file)
    Marshal.dump($game_actors, file)
    Marshal.dump($game_party, file)
    Marshal.dump($game_troop, file)
    Marshal.dump($game_map, file)
    Marshal.dump($game_player, file)
  end
end

#==============================================================================
# Scene_End
#------------------------------------------------------------------------------
# Esta classe processa a tela de Game Over
#==============================================================================

class Scene_End
  
  #--------------------------------------------------------------------------
  # Processamento Principal
  #--------------------------------------------------------------------------
  
  def main
    # Criar janela de comandos
    s1 = "Ir à Tela de Título"
    s2 = "Sair"
    s3 = "Cancelar"
    @command_window = Window_Command.new(192, [s1, s2, s3])
    @command_window.x = 320 - @command_window.width / 2
    @command_window.y = 240 - @command_window.height / 2
    # Executar transição
    Graphics.transition
    # Lopping principal
    loop do
      # Atualizar tela de jogo
      Graphics.update
      # Atualizar entrada de informações
      Input.update
      # Atualização do Frame
      update
      # Aboratar loop se a tela se modificar
      if $scene != self
        break
      end
    end
    # preparar para a transição
    Graphics.freeze
    # Exibição da janela
    @command_window.dispose
    # Se alternar para a Tela de Título
    if $scene.is_a?(Scene_Title)
      # Desaparecimento gradual da tela
      Graphics.transition
      Graphics.freeze
    end
  end
  
  #--------------------------------------------------------------------------
  # Atualização do Frame
  #--------------------------------------------------------------------------
  
  def update
    # Atualizar janela de comandos
    @command_window.update
    # Se o botão B for pressionado
    if Input.trigger?(Input::B)
      # Reproduzir SE de cancelamento
      $game_system.se_play($data_system.cancel_se)
      # Alternar para a tela de Menu
      $scene = Scene_Menu.new(3)
      return
    end
    # Se o botão C for pressionado
    if Input.trigger?(Input::C)
      # Ramificação por posição na janela de comandos
      case @command_window.index
      when 0  # Ir à tela de título
        command_to_title
      when 1  # Sair
        command_shutdown
      when 2  # Cancelar
        command_cancel
      end
      return
    end
  end
  
  #--------------------------------------------------------------------------
  # Processamento na Escolha do Comando Ir à Tela de Título
  #--------------------------------------------------------------------------
  
  def command_to_title
    # Reproduzir SE de OK
    $game_system.se_play($data_system.decision_se)
    # Diminuir gradualmente o volume de GBM, BGS e ME
    Audio.bgm_fade(800)
    Audio.bgs_fade(800)
    Audio.me_fade(800)
    # Alternar para a tela de Título
    $scene = Scene_Title.new
  end
  
  #--------------------------------------------------------------------------
  # Processamento na Escolha do Comando Sair
  #--------------------------------------------------------------------------
  
  def command_shutdown
    # Repdoduzir SE de OK
    $game_system.se_play($data_system.decision_se)
    # Diminuir gradualmente o volume de GBM, BGS e ME
    Audio.bgm_fade(800)
    Audio.bgs_fade(800)
    Audio.me_fade(800)
    # Sair
    $scene = nil
  end
  
  #--------------------------------------------------------------------------
  # Processamento na Escolha do Comando Cancelar
  #--------------------------------------------------------------------------
  
  def command_cancel
    # Reproduzir SE de OK
    $game_system.se_play($data_system.decision_se)
    # Alternar para a tela do Menu
    $scene = Scene_Menu.new(3)
  end
end