Problema com script de quest [RMVX]---[RESOLVIDO]

[DeadMaker]

Aew galera queria deixar meu game muito personalizado !!! Mais eu arrumo um problema ia aparece outro eu n entendo nad d scripts queria sabe d alguem q intend ! Vou colocar aki imagens para vcs intenderem melhor !



se nao der para ver ve aki ! http://a.imageshack.us/img341/5678/semttuloeho.png
O erro esta na linha cinza 924!

Ai quando executo o jogo da isso :



Por favor algum me ajuda !!!Desde ja vlws !!

[rafajujuba]

Cara, vc arranjou um problemão. Se não sabia mexer em scripts pedia ajuda na lua.
Se quer fazer o jogo voltar a funcionar restaura os scripts. Copia e cola de um projeto em branco.

OBS:dei uma olhada nos titulos dos scripts, e parece que o jogo vai ficar bom.
Boa sorte ai.!!!

[Kyo Panda]

Eu observei o script e não verifiquei erro algum. Veja se você não mudou o nome do módulo de configuração, o ModAlg_QuestData.
Ou então, insira novamente o script no jogo:

Código:

#==============================================================================
# Quest Journal [VX]
#------------------------------------------------------------------------------
# Cria um sistema de Quest no jogo, ou seja, um sistema onde é necessário
# que algumas missões sejam completadas para o prosseguimento do jogo.
#------------------------------------------------------------------------------
# Autor: modern algebra (rmrk.net)
# Lançado em: 24\03\2008
# Versão: 1.1
# Tradução PT: Kyo Panda (http://www.mundorpgmaker.com/)
#==============================================================================

#==============================================================================
# Funções:
#------------------------------------------------------------------------------
# - Basicamente, esse script é um sistema de quest baseado em objetivos que
# permite ao jogador fazer quests e revelá-las aos personagens chamando alguns
# scripts específicos. Este baseamento em objetivos significa que, somente se
# avança no jogo se o jogador completar certos objetivos, que você pode
# escolher quando revelá-los e quando definí-los completos ou falidos. Sendo
# assim, este script não constrói quests, mas o dá, mais ou menos, uma
# interface gráfica para mostrar o progresso dela. O script não funciona se
# apenas chamá-lo, então, leia as instruções cuidadosamente se você quer usar
# este script.
#==============================================================================

#==============================================================================
# Como usar:
#------------------------------------------------------------------------------
#
# #--------------------------------------------------------------------------
# # Instalação:
# #--------------------------------------------------------------------------
#
# Cole esse script acima do "Main" e abaixo dos "Scripts Adicionais".
#
# Basicamente, configure todas as suas quests no guia "Configuração" logo
# abaixo (linha 128). A seção "Constantes" (linha 138) é que configura a base
# do sistema, então, leia os comentários ao lado delas para determinar os seus
# valores. Como você pode ver, elas já estão preenchidas com valores padrões
# atualmente, já elas poderão lhe dar uma idéia do que fazer.
#
# Configurar as quests podem ser um pouco difícel. Você terá que configurar
# cada uma no script para que se possa representar no jogo. Veja o guia
# "Configuração das Quest" (linha 155) para maiores informações.
# 
# #--------------------------------------------------------------------------
# # Utilização:
# #--------------------------------------------------------------------------
# 
# Uma vez que tudo estiver configurado, você pode ativá-las no jogo usando
# este código:
#
# $game_party.quests[ID_da_Quest]
#
# Você pode chama este código de várias maneiras, adicionando uma função após
# ela. Exemplos:
#
# - Revela o objetivo no menu Quest para ser visualizado pelo jogador.
# $game_party.quests[ID_da_Quest].reveal_objective (ID_do_Objetivo)
#
# - Oculta o objetivo no menu Quest.
# $game_party.quests[ID_da_Quest].conceal_objective (ID_do_Objetivo)
#
# - Define o objetivo como completo.
# $game_party.quests[ID_da_Quest].complete_objective (ID_do_Objetivo)
#
# - Redefine o objetivo como imcompleto.
# $game_party.quests[ID_da_Quest].uncomplete_objective (ID_do_Objetivo)
#
# - Define o objetivo como falido.
# $game_party.quests[ID_da_Quest].fail_objective (ID_do_Objetivo)
#
# - Redefine o objetivo como não-falido.
# $game_party.quests[ID_da_Quest].unfail_objective (ID_do_Objetivo)
#
# - Define a Quest como completa se todos os objetivos estiverem completos.
# $game_party.quests[ID_da_Quest].complete?
#
# - Define a Quest como falida se todos os objetivos estiverem falidos.
# $game_party.quests[ID_da_Quest].failed?
#
# - Cancela (ou descancela) a Quest (true = Cancela e false = Descancela)
# $game_party.quests[ID_da_Quest].concealed = true/false
#
# - Remove a Quest do jogo.
# $game_party.quests.remove (ID_da_Quest)
#
# - Dá uma recompensa pelo término da Quest (true = Sim e false = Não).
# $game_party.quests[ID_da_Quest].reward_given = true/false
#
# A opção de recompensa serve como uma switch. Você deve essencialmente fazer
# evento para que ocorra a mesma. Mais ou menos assim:
#
# # Se a Quest foi completada.
# <> Condição: Script: $game_party.quests[ID_da_Quest].complete?
# # Verifica se a recompensa foi dada.
#  <> Condição: Script: $game_party.quests[ID_da_Quest].reward_given
#  # Se já foi dada a recompensa (true), não da nada.
#  :  Exceção:
#  # Se não foi dada a recompensa (false), dá a recompensa.
#      <> Mudar Dinheiro: +1000
#      # Define que a recompensa foi dada (true).
#      <> Script: $game_party.quests[ID_da_Quest].reward_given = true
#      FIM
# # Se a Quest não foi completada
# : Exceção:
# # Não dá a recompensa.
#  FIM
#
#
# Versões posteriores deste script terão um sistema de auto-recompensa e também
# um Diário para que o jogador possa escrever notas no decorrer da Quest.
#
# - Você pode desabilitar o Menu de Quest a qualquer hora com o código:
# $game_system.quest_disabled = true
#
# - E você pode modificar o modo como o Menu de Quest é ativado com os códigos:
# $game_system.quest_keyaccess = true / false  # No mapa
# $game_system.quest_menuaccess = true / false # No menu
#
# - Também, em uma mensagem, \nq[ID_da_Quest] irá retornar o nome da Quest e
# exibi-lá na mensagem.
#==============================================================================

#==============================================================================
# ModAlg_QuestData
#------------------------------------------------------------------------------
# Módulo que armazena todas as configurações do script Quest Journal
#==============================================================================

module ModAlg_QuestData
  #--------------------------------------------------------------------------
  # Configuração:
  #--------------------------------------------------------------------------
 
  #--------------------------------------------------------------------------
  # Constantes
  #--------------------------------------------------------------------------
  # Aqui se configura a base do script.
  #--------------------------------------------------------------------------
  QUESTS_LABEL = 'Quests'    # O nome do Menu de Quests (Ex: Missões)
  DESCRIPTION = 'Descrição'  # O nome "Descrição" no menu Quest
  OBJECTIVES = 'Objetivos'    # O nome "Objetivos" no menu Quest
  ACTIVE_QUEST_ICON = 149    # O ícone que indica que a Quest está ativa
  COMPLETE_QUEST_ICON = 150  # O ícone que indica que a Quest está completa
  FAILED_QUEST_ICON = 179    # O ícone que indica que a Quest está falida
  BULLET_CHARACTER = '●'      # O caractere utilizado para listar os objetivos
  ACTIVE_COLOUR = 0          # A cor da Quest que está ativa
  COMPLETE_COLOUR = 11        # A cor da Quest que está completa
  FAILED_COLOUR = 18          # A cor da Quest que está falida
  MENU_ACCESS = true          # Este script pode ser acessado pelo menu do jogo?
  MENU_INDEX = 4              # Se acima for true, aonde no menu do jogo?
  KEY_ACCESS = false          # Este script pode ser acessado por uma tecla?       
  MAPKEY_BUTTON = Input::L    # Se acima for true, qual botão?
  #-------------------------------------------------------------------------
  # Dados da Quest
  #-------------------------------------------------------------------------
  # Aqui se configura todas as Quests utilizadas no jogo.
  #-------------------------------------------------------------------------
  def self.quest_data (id)
    # Defina os valores padrões das Quests que não os tiverem definidos
    objectives  = []
    name        = '??????'
    description = '??????????'
    icon_index  = 0
    case id
  #-------------------------------------------------------------------------
  # Configuração das Quests
  #-------------------------------------------------------------------------
  # Para configurar uma Quest, primeira identifique-a com um ID - isto pode
  # ter qualquer valor desde que não haja outra Quest com o mesmo valor, mas,
  # é importante lembrar que este ID é o único modo de acessar a sua Quest.
  # Neste caso, o formato para configurar uma Quest é o seguinte:
  #
  # when ID_da_Quest # Dê um número de ID à Quest
  #  name          = 'Nome da Quest'
  #  description  = 'Descrição da Quest'
  #  objectives[0] = 'Descrição do primeiro objetivo'
  #  ...
  #  objectives[n] = 'Descrição do n objetivo'
  #  prime        = [ID_do_Objetivo, ..., ID_do_Objetivo]
  #  icon_index    = Index_do_ícone_da_Quest
  #
  # Cada um desses valores possue sua importância:
  #
  # "name" é o nome da Quest.
  # "description" é um pequeno resumo do objetivo da Quest.
  # "objective[0..n]" são os objetivos a serem concluídos para o fim da Quest.
  # "primes" são os objetivos que devem ser concluídos para o término da Quest.
  # "icon_index" é o ícone que representa a Quest.
  #
  # Note que qualquer um dos itens acima podem ser omitidos sem que retornem
  # erros. Mas, para que a Quest funcione devidamente, você deve definir o
  # nome, a descrição, e os objetivos. Se você os omitir, os valores padrão
  # são:
  # 
  # name        = '??????'
  # description = '??????????'
  # objectives  = []
  # prime      = [Todos os objetivos]
  # icon_index  = 0
  #
  # Se você quer que seja necessário que todos os objetivos sejam completados
  # para a conclusão da Quest, então não se importe em definir o "prime".
  # Senão, esteja certo de definí-lo.
  #--------------------------------------------------------------------------
    when 0 # Vai buscar!
      name = 'Vai buscar!'
      description = 'Martha precisa que alguém brinque com seu cachorro.'
      objectives[0] = 'Ache a vareta.'
      objectives[1] = 'Atire a vareta para o cachorro.'
      objectives[2] = 'Pegue a vareta devolta do cachorro.'
      icon_index = 79
    when 1 # Resgate o gato!
      name = 'Resgate o gato!'
      description = 'Sra. Bunderby perdeu o seu gato e ela o contratou para achá-lo.'
      objectives[0] = 'Encontre o gato perdido.'
      objectives[1] = 'Suba na árvore e resgate o gato.'
      objectives[2] = "Devolva o gato à Sra. Bunderby."
      # Define os objetivos principais na Array
      prime = [0, 2]
      icon_index = 137
  #--------------------------------------------------------------------------
  # Fim da configuração.
  #--------------------------------------------------------------------------
    end
    return name, description, objectives, prime, icon_index
  end
 
#==============================================================================
# Quest
#------------------------------------------------------------------------------
# Classe que armazena as configurações padrões das Quests.
#==============================================================================

  class Quest
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
    attr_reader  :name                # O nome da Quest
    attr_reader  :id                  # O ID em $game_party.quests
    attr_reader  :description        # A descrição da Quest
    attr_reader  :objectives          # Uma array com as strings contendo os objetivos
    attr_reader  :prime_objectives    # Uma array com os objetivos principais
    attr_reader  :icon_index          # O ícone associado à Quest
    attr_reader  :revealed_objectives # Uma array com os objetivos revelados
    attr_reader  :complete_objectives # Uma array com os objetivos completos
    attr_reader  :failed_objectives  # Uma array com os objetivos falidos
    attr_accessor :reward_given        # Uma switch que garante apenas uma recompensa
    attr_accessor :concealed          # Uma switch que mostra ou não mostra a Quest
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
    def initialize (id)
      @id = id
      # Define as variáveis de classe com os argumentos correspondentes
      @name, @description, @objectives, prime, @icon_index = ModAlg_QuestData.quest_data (id)
      # Se os objetivos principais não forem definidos
      if prime.nil?
        # Todos os objetivos se tornam principais
        prime = []
        for i in 0...@objectives.size
          prime.push (i)
        end
      end
      @prime_objectives = prime
      # Inicialização das arrays não-públicas
      @revealed_objectives = []
      @complete_objectives = []
      @failed_objectives = []
      @reward_given = false
      @concealed = false
    end
  #--------------------------------------------------------------------------
  # Revelar objetivos
  #--------------------------------------------------------------------------
    def reveal_objective (index)
      return if index >= @objectives.size
      # Adiciona os objetivos revelados
      @revealed_objectives |= [index]
      # Dispõe do menor index para o maior index
      @revealed_objectives.sort!
    end
  #--------------------------------------------------------------------------
  # Ocultar objetivos
  #--------------------------------------------------------------------------
    def conceal_objective (index)
      @revealed_objectives.delete (index)
    end
  #--------------------------------------------------------------------------
  # Objetivo completo
  #--------------------------------------------------------------------------
    def complete_objective (index)
      return if index >= @objectives.size
      # Se o objetivo está falido, você não pode completá-lo
      return if @failed_objectives.include? (index)
      # Revela o objetivo se não foi previamente revelado
      reveal_objective (index) unless @revealed_objectives.include? (index)
      # Adiciona os objetivos completos
      @complete_objectives |= [index]
      # Dispõe do menor index para o maior index
      @complete_objectives.sort!
    end
  #--------------------------------------------------------------------------
  # Objetivo incompleto
  #--------------------------------------------------------------------------
    def uncomplete_objective (index)
      @complete_objectives.delete (index)
    end
  #--------------------------------------------------------------------------
  # Objetivo falido
  #--------------------------------------------------------------------------
    def fail_objective (index)
      return if index >= @objectives.size
      # Revela o objetivo se ele ainda não foi revelado
      reveal_objective (index) unless @revealed_objectives.include? (index)
      # Adiciona o objetivo revelado
      @failed_objectives |= [index]
      # Dispõe do menor index para o maior index
      @failed_objectives.sort!
    end
  #--------------------------------------------------------------------------
  # Objetivo não-falido
  #--------------------------------------------------------------------------
    def unfail_objective (index)
      @failed_objectives.delete (index)
    end
  #--------------------------------------------------------------------------
  # Completo?
  #--------------------------------------------------------------------------
    def complete?
      # Confere se todos os objetivos principais estão completos
      return (@complete_objectives & @prime_objectives) == @prime_objectives
    end
  #--------------------------------------------------------------------------
  # Falido?
  #--------------------------------------------------------------------------
    def failed?
      # Confere se todos os objetivos principais estão falidos
      return (@failed_objectives & @prime_objectives) != []
    end
  end
end

#==============================================================================
# Ellipse
#------------------------------------------------------------------------------
# Armazena um objeto elíptico.
#==============================================================================

class Ellipse
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader  :a # A largura do círculo
  attr_reader  :b # A altura do círculo
  attr_reader  :x # O posicionamento horizontal
  attr_reader  :y # O posicionamento vertical
  attr_reader  :h # O posicionamento horizontal em sua origem
  attr_reader  :k # O posicionamento vertical em sua origem
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #  x : o posicionamento horizontal
  #  y : o posicionamento vertical
  #  a : a largura do círculo em sua origem do seu lado
  #  b : a altura do círculo em sua origem. Se nil, é o radius do círculo
  #--------------------------------------------------------------------------
  def initialize (x, y, a, b = nil)
    @x = x
    @y = y
    @a = a
    @b = b.nil? ? a : b
    @h = x + a
    @k = y + @b
  end
  #--------------------------------------------------------------------------
  # Em conjunto?
  #  x : a coordenada horizontal sendo testada
  #  y : a coordenada vertical sendo testada
  #--------------------------------------------------------------------------
  def within? (x, y)
    x_square = ((x - @h)*(x - @h)).to_f / (@a*@a)
    y_square = ((y - @k)*(y - @k)).to_f / (@b*@b)
    # Se "radius" <= 1, então isso deve estar em conjunto com a ellipse
    return (x_square + y_square) <= 1
  end
end

#==============================================================================
# Bitmap
#------------------------------------------------------------------------------
# Classe que comanda toda e qualquer imagem exibida no jogo.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novos métodos: outiline_ellipse, fill_ellipse e fill_rounded_rect.
#==============================================================================

class Bitmap
  #--------------------------------------------------------------------------
  # Contorno da elipse
  #  ellipse : a elipse sendo desenhada
  #  width  : a largura da barra
  #  colour  : a cor do contorno
  #--------------------------------------------------------------------------
  def outline_ellipse (ellipse, colour = font.color, width = 1, steps = 0)
    # Para organização, define as variáveis locais a e b para as variáveis de elipse
    a, b = ellipse.a, ellipse.b
    # Usa a aproximação de Ramanujan para a circunferência da elipse
    steps = Math::PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) if steps == 0
    radian_modifier = (2*Math::PI) / steps
    for i in 0...steps
      t = (radian_modifier*i) % (2*Math::PI)
      # Expressada parametricamente:
      #  x = h + acos(t), y = k + bsin(t) : onde t vai de 0 a 2pi
      x = (ellipse.h + (a*Math.cos(t)))
      y = (ellipse.k + (b*Math.sin(t)))
      set_pixel (x, y, colour)
    end
    # Reforça a linha
    if width > 1
      ellipse = Ellipse.new (ellipse.x + 1, ellipse.y + 1, ellipse.a - 1, ellipse.b - 1)
      outline_ellipse (ellipse, colour, width - 1, steps)
    end
  end
  #--------------------------------------------------------------------------
  # Preenche a elipse
  #  ellipse : a elipse sendo desenhada
  #  colour  : a cor do contorno
  #--------------------------------------------------------------------------
  def fill_ellipse (ellipse, colour = font.color, steps = 0)
    # Para organização, define as variáveis locais a e b para as variáveis de elipse
    a, b = ellipse.a, ellipse.b
    # Usa a aproximação de Ramanujan para a circunferência da elipse
    steps = Math::PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) if steps == 0
    radian_modifier = (2*Math::PI) / steps
    for i in 0...(steps / 2)
      t = (radian_modifier*i) % (2*Math::PI)
      # Expressada parametricamente:
      #  x = h + acos(t), y = k + bsin(t) : onde t vai de 0 a 2pi
      x = ellipse.h + (a*Math.cos(t))
      y = ellipse.k - (b*Math.sin(t))
      fill_rect (x, y, 1, 2*(ellipse.k - y), colour)
    end
  end
  #--------------------------------------------------------------------------
  # Preenche retângulo circular
  #  rect    : o retângulo sendo desenhado
  #  colour  : a cor do contorno
  #  w      : o número de pixels para cobrir o círculo
  #--------------------------------------------------------------------------
  # Usado para preencher retângulos com cantos circulares
  #--------------------------------------------------------------------------
  def fill_rounded_rect (rect, colour = font.color, w = 8)
    # Desenha o corpo do retângulo
    fill_rect (rect.x + w, rect.y, rect.width - 2*w, rect.height, colour)
    # Desenha o retângulo horizontal
    fill_rect (rect.x, rect.y + w, w, rect.height - 2*w, colour)
    # Desenha o retângulo vertical
    x = rect.x + rect.width - w
    fill_rect (x, rect.y + w, w, rect.height - 2*w, colour)
    # Faz um círculo
    circle = Ellipse.new (0, 0, w)
    for i in 0...w
      for j in 0...w
        # Canto superior esquerdo
        set_pixel (rect.x + i, rect.y + j, colour) if circle.within? (i, j)
        # Canto superior direito
        set_pixel (rect.x + rect.width - w + i, rect.y + j, colour) if circle.within? (i + w, j)
        # Canto inferior esquerdo
        set_pixel (rect.x + i, rect.y + rect.height - w + j, colour) if circle.within? (i, j + w)
        # Canto inferior direito
        set_pixel (rect.x + rect.width - w + i, rect.y + rect.height - w + j, colour) if circle.within? (i + w, j + w)
      end
    end
  end
end

#==============================================================================
# Window_VarySizeHelp
#------------------------------------------------------------------------------
# A janela é a mesma que a Window_Help, mas com tamanho de variável
#==============================================================================

class Window_VarySizeHelp < Window_Help
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize (h_x = 0, h_y = 0, h_width = Graphics.width, h_height = WLH + 32)
    super ()
    self.x, self.y, self.width, self.height = h_x, h_y, h_width, h_height
    contents.dispose
    self.contents = Bitmap.new (h_width - 32, h_height - 32)
  end
end

#==============================================================================
# Game_System
#------------------------------------------------------------------------------
# Esta classe controla os dados em torno do sistema de jogo. Ela controla os
# veículos, músicas, etc. Pode ser acessada utilizando $game_system.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Novas variáveis públicas: quest_disabled, quest_keyaccess
# - Alias do método: initialize
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :quest_disabled  # Você pode acessar o Diário nessa hora?
  attr_accessor :quest_keyaccess  # É acessível por uma tecla?
  attr_accessor :quest_menuaccess # É acessível pelo menu?
  #--------------------------------------------------------------------------
  # Alias da icialização do objeto
  #--------------------------------------------------------------------------
  alias modalg_qst_jrnl_system_init_quests initialize
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    # Rodar método original
    modalg_qst_jrnl_system_init_quests
    # Inicialização das novas variáveis
    @quest_disabled = false
    @quest_keyaccess = ModAlg_QuestData::KEY_ACCESS
    @quest_menuaccess = ModAlg_QuestData::MENU_ACCESS
  end
end

#==============================================================================
# Game_Party
#------------------------------------------------------------------------------
# Classe que trata do Grupo. Inclui informações sobre dinheiro, itens, etc.
# Pode ser acessada utilizando $game_party.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Nova variável pública: quests
# - Alias do método: initialize
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader  :quests
  #--------------------------------------------------------------------------
  # Alias da inicialização do objeto
  #--------------------------------------------------------------------------
  alias modalg_qst_jrnl_party_init_quests initialize
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    # Rodar método original
    modalg_qst_jrnl_party_init_quests
    # Inicialização da @quests
    @quests = Game_Quests.new
  end
end

#==============================================================================
# Game_Quests
#------------------------------------------------------------------------------
# Classe que define as Quests. É uma modificação da classe "Hash". A instância
# dessa classe pode ser acessada por $game_party.quests.
#==============================================================================

class Game_Quests
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    @data = {}
  end
  #--------------------------------------------------------------------------
  # Adquirir Quest
  #  quest_id : o ID da Quest
  #--------------------------------------------------------------------------
  def [] (quest_id)
    @data[quest_id] = ModAlg_QuestData::Quest.new (quest_id) if @data[quest_id] == nil
    return @data[quest_id]
  end
  #--------------------------------------------------------------------------
  # Adquirir lista de Quests
  #--------------------------------------------------------------------------
  def list
    quest_list = @data.values
    quest_list.each { |i| quest_list.delete (i) if i.concealed }
    return quest_list
  end
  #--------------------------------------------------------------------------
  # Adquirir lista de Quests completas
  #--------------------------------------------------------------------------
  def completed_list
    complete_quests = []
    list.each { |i| complete_quests.push (i) if i.complete? }
    return complete_quests
  end
  #--------------------------------------------------------------------------
  # Adquirir lista de Quests falidas
  #--------------------------------------------------------------------------
  def failed_list
    failed_quests = []
    list.each { |i| failed_quests.push (i) if i.failed? }
    return failed_quests
  end
  #--------------------------------------------------------------------------
  # Adquirir lista de Quests ativas
  #--------------------------------------------------------------------------
  def active_list
    return list - failed_list - completed_list
  end
  #--------------------------------------------------------------------------
  # Revelado?
  #  quest_id : o ID da Quest conferida
  #--------------------------------------------------------------------------
  def revealed? (quest_id)
    return @data[quest_id] != nil
  end
  #--------------------------------------------------------------------------
  # Remover Quest
  #  quest_id : o ID da Quest conferida
  #--------------------------------------------------------------------------
  def remove (quest_id)
    @data.delete (quest_id)
  end
  #--------------------------------------------------------------------------
  # Limpar
  #--------------------------------------------------------------------------
  def clear
    @data.clear
  end
end

#==============================================================================
# Window_Command
#------------------------------------------------------------------------------
# Esta é a janela que faz uma seleção geral de comandos.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Nova variável pública: disabled_commands
# - Alias dos métodos: initialize e draw_item
#==============================================================================

class Window_Command
  #--------------------------------------------------------------------------
  # Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :disabled_commands
  #--------------------------------------------------------------------------
  # Alias da inicialização do objeto
  #--------------------------------------------------------------------------
  alias modalg_quest_jrnl_intlz initialize
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #  width      : largura da janela
  #  commands  : string da array dos comandos
  #  column_max : contagem de digitos (se 2 ou mais, seleção horizontal)
  #  row_max    : contagem da rolagem (0: coincide com os comandos)
  #  spacing    : espaço em branco onde os itens são organizados
  #                horizontalmente
  #--------------------------------------------------------------------------
  def initialize(width, commands, column_max = 1, row_max = 0, spacing = 32)
    # Inicialização das novas variáveis de instância
    @disabled_commands = []
    # Rodar método original
    modalg_quest_jrnl_intlz (width, commands, column_max, row_max, spacing)
  end
  #--------------------------------------------------------------------------
  # Alias do desenhar item
  #--------------------------------------------------------------------------
  alias modalg_quest_jrnl_itm_drw draw_item
  #--------------------------------------------------------------------------
  # Desenhar item
  #  index  : número do item
  #  enabled : opção ativado. Quando false, desenha semi-transparente
  #--------------------------------------------------------------------------
  def draw_item (index, enabled = true)
    # Run Original Method
    modalg_quest_jrnl_itm_drw (index, enabled)
    enabled ? @disabled_commands.delete (index) : @disabled_commands.push (index)
  end
end

#==============================================================================
# Window_Message
#------------------------------------------------------------------------------
# Janela reponsável pela exibição de sentenças na caixa de mensagens.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Alias do método: convert_special_characters
#==============================================================================

class Window_Message
  #--------------------------------------------------------------------------
  # Alias do conversão de caracteres especiais
  #--------------------------------------------------------------------------
  alias modalg_quest_jrnl_spec_char_convert convert_special_characters
  #--------------------------------------------------------------------------
  # Conversão de caracteres especiais
  #--------------------------------------------------------------------------
  def convert_special_characters
    @text.gsub! (/\\NQ\[(\d+)\]/i) { $game_party.quests[$1.to_i] } # Nome da Quest
    # Rodar método original
    modalg_quest_jrnl_spec_char_convert
  end
end

#==============================================================================
# Window_QuestLabel
#------------------------------------------------------------------------------
# Esta janela significa que esta é a lista de Quests.
#==============================================================================

class Window_QuestLabel < Window_Base
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super (0, 0, 160 + WLH, 32 + WLH)
    create_contents
    contents.font.color = system_color
    contents.draw_text (0, 0, contents.width, WLH, ModAlg_QuestData::QUESTS_LABEL, 1)
  end
end

#==============================================================================
# Window_QuestCategory
#------------------------------------------------------------------------------
# Esta janela mostra qual categoria está sendo vista.
#==============================================================================

class Window_QuestCategory < Window_Base
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super (0, WLH + 32, 160 + WLH, 64)
    create_contents
  end
  #--------------------------------------------------------------------------
  # Atualização
  #  category_index : ícone a ser destacado - 0 = Todos, 1 = Ativos,
  #                    2 = Completos, 3 = Falidos
  #--------------------------------------------------------------------------
  def refresh (category_index = 0)
    contents.clear
    # Adquire o Bitmap dos itens
    bitmap = Cache.system("Iconset")
    icon_index = ModAlg_QuestData::ACTIVE_QUEST_ICON
    active_rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    icon_index = ModAlg_QuestData::COMPLETE_QUEST_ICON
    complete_rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    icon_index = ModAlg_QuestData::FAILED_QUEST_ICON
    failed_rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    # Combina os três ícones para o ícone 'Todos'
    all_icon = Bitmap.new (40, 32)
    all_icon.blt (0, 0, bitmap, complete_rect)
    all_icon.blt (20, 0, bitmap, failed_rect)
    all_icon.blt (8, 10, bitmap, active_rect)
    distance = (contents.width - 112) / 3
    x = 0
    # Desenha o ícone 'Todos' na janela
    contents.blt (x, 0, all_icon, all_icon.rect, category_index == 0 ? 255 : 128)
    x += 40 + distance
    # Desenha o ícone 'Ativos' no janela
    contents.blt (x, 4, bitmap, active_rect, category_index == 1 ? 255 : 128)
    x += 24 + distance
    # Desenha o ícone 'Completos' na janela
    contents.blt (x, 4, bitmap, complete_rect, category_index == 2 ? 255 : 128)
    x += 24 + distance
    # Desenha o ícone 'Falidos' na janela
    contents.blt (x, 4, bitmap, failed_rect, category_index == 3 ? 255 : 128)
  end
end

#==============================================================================
# Window_QuestList
#------------------------------------------------------------------------------
# Esta janela mostra a lista de Quests.
#==============================================================================

class Window_QuestList < Window_Selectable
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize (category_index = 0, index = 0)
    super (0, 64 + (WLH + 32), 160 + WLH, Graphics.height - 64 - 2*(WLH + 32))
    @data = []
    @column_max = 1
    refresh (category_index)
    self.index = index
    self.active = true
  end
  #--------------------------------------------------------------------------
  # Quest
  #--------------------------------------------------------------------------
  def quest
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # Atualização
  #  category_index : ícone a ser destacado - 0 = Todos, 1 = Ativos,
  #                    2 = Completos, 3 = Falidos
  #--------------------------------------------------------------------------
  def refresh (category_index = 0)
    font = Font.new
    @data.clear
    self.index = 0
    # Adquire a lista de Quests a ser desenhada
    case category_index
    when 0
      @data = $game_party.quests.list
    when 1
      @data = $game_party.quests.active_list
      font.color = text_color (ModAlg_QuestData::ACTIVE_COLOUR)
    when 2
      @data = $game_party.quests.completed_list
      font.color = text_color (ModAlg_QuestData::COMPLETE_COLOUR)
    when 3
      @data = $game_party.quests.failed_list
      font.color = text_color (ModAlg_QuestData::FAILED_COLOUR)
    end
    @item_max = @data.size
    unless contents == nil
      # Limpar contents
      contents.clear
      return if @data.empty?
      contents.dispose
    end
    # Criar contents
    self.contents = Bitmap.new (width - 32, WLH*@data.size)
    contents.font = font
    # Desenhar o nome das Quests
    for i in 0...@data.size
      quest = @data[i]
      # Se tudo, distinguir Quests por cores
      if category_index == 0
        if quest.complete?
          contents.font.color = text_color (ModAlg_QuestData::COMPLETE_COLOUR)
        elsif quest.failed?
          contents.font.color = text_color (ModAlg_QuestData::FAILED_COLOUR)
        else # Ativos
          contents.font.color = text_color (ModAlg_QuestData::ACTIVE_COLOUR)
        end
      end
      draw_icon (quest.icon_index, 0, i*WLH)
      # Desenhar o nome das Quests
      contents.draw_text (24, i*WLH, contents.width - 24, WLH, quest.name)
    end
  end
end

#==============================================================================
# Window_QuestInfo
#------------------------------------------------------------------------------
# Esta janela mostra a informação da Quest sendo vista.
#==============================================================================

class Window_QuestInfo < Window_Base
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super (160 + WLH, 0, Graphics.width - (160 + WLH), Graphics.height - (32 + WLH))
    create_contents
  end
  #--------------------------------------------------------------------------
  # Atualização
  #--------------------------------------------------------------------------
  def refresh (quest = nil)
    contents.clear
    return if quest == nil
    # Desenha o nome da Quest, centralizado
    contents.font.color = normal_color
    contents.draw_text (0, 0, contents.width, WLH, quest.name, 1)
    # Se a fonte tiver definido a largura dos caracteres
    if contents.text_size ('w').width == contents.text_size ('i').width
      formatter = Paragrapher::Formatter_2.new
    else
      formatter = Paragrapher::Formatter.new
    end
    # Formatar descrição
    desc_bitmap = Bitmap.new (contents.width - 16, (2.4*WLH).to_i)
    desc_bitmap.font.size -= 4
    formatted_desc = formatter.format (quest.description, desc_bitmap)
    # Desenhar caixa de descrição
    box_height = [WLH*(formatted_desc.lines.size + 1), 3*WLH].min
    rect = Rect.new (2, (1.5*WLH).to_i, contents.width - 4, box_height)
    contents.fill_rounded_rect (rect, system_color, 10)
    rect.x, rect.y = rect.x + 2, rect.y + 2
    rect.width, rect.height = rect.width - 4, rect.height - 4
    contents.fill_rounded_rect (rect, Color.new (0, 0, 0, 0), 10)
    tw = contents.text_size (ModAlg_QuestData::DESCRIPTION).width
    # Desenhar o significado da descrição
    contents.fill_rect (32, (1.5*WLH).to_i, tw + 2, 2, Color.new (0, 0, 0, 0))
    contents.font.color = system_color
    contents.draw_text (33, WLH, tw, WLH, ModAlg_QuestData::DESCRIPTION)
    # Paragraph Artist
    artist = Paragrapher::Artist.new
    # Se o Bitmap for muito grande
    if formatted_desc.lines.size < 2
      formatted_desc.bitmap = Bitmap.new (contents.width - 16, formatted_desc.lines.size*WLH)
      formatted_desc.bitmap.font.size -= 4
    end
    bmp = artist.draw (formatted_desc)
    # Centralizar com a caixa
    y = rect.y + 4 + (rect.height - bmp.height) / 2
    contents.blt (8, y, bmp, bmp.rect)
    bmp.dispose
    y = 2*WLH + rect.height + 4
    # Desenhar o texto do significado dos objetivos
    contents.font.color = system_color
    tw = contents.text_size (ModAlg_QuestData::OBJECTIVES).width
    contents.draw_text (32, y, tw, WLH, ModAlg_QuestData::OBJECTIVES)
    y += WLH
    quest.revealed_objectives.each { |i|
      # Adquirir a cor correta
      contents.font.color = quest.complete_objectives.include? (i) ?
        text_color (ModAlg_QuestData::COMPLETE_COLOUR) : quest.failed_objectives.include? (i) ?
        text_color (ModAlg_QuestData::FAILED_COLOUR) : text_color (ModAlg_QuestData::ACTIVE_COLOUR)
      # Adquirir objetivo
      objective = quest.objectives[i]
      # Desenhar marcador
      tw = contents.text_size (ModAlg_QuestData::BULLET_CHARACTER).width
      x = 8
      contents.draw_text (x, y, tw, WLH, ModAlg_QuestData::BULLET_CHARACTER)
      x += tw + 4
      # Formatar o objetivo
      obj_bitmap = Bitmap.new (contents.width - x, 2*WLH)
      obj_bitmap.font = contents.font
      obj_bitmap.font.size -= 4
      formatted_obj = formatter.format (objective, obj_bitmap)
      # Desenhar o objetivo
      bmp = artist.draw (formatted_obj)
      contents.blt (x, y + 4, bmp, bmp.rect)
      # Modificar y de acordo
      y += WLH*([formatted_obj.lines.size, 2].min)
    }
  end
end

#==============================================================================
# Scene_Map
#------------------------------------------------------------------------------
# Classe das operações nos mapas.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Alias do método: update.
#==============================================================================

class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # Alias da atualização de tela
  #--------------------------------------------------------------------------
  alias modalg_quest_journal_map_upd_key_access update
  #--------------------------------------------------------------------------
  # Atualização de tela
  #--------------------------------------------------------------------------
  def update
    modalg_quest_journal_map_upd_key_access
    # Se o Menu de Quest pode ser acessado por uma tecla e não está vazia ou
    # disbilitada.
    if $game_system.quest_keyaccess && !$game_system.quest_disabled && !$game_party.quests.list.empty?
      $scene = Scene_Quest.new if Input.trigger? (ModAlg_QuestData::MAPKEY_BUTTON)
    end
  end
end

#==============================================================================
# Scene_Menu
#------------------------------------------------------------------------------
# Classe de operações na tela do menu.
#------------------------------------------------------------------------------
# Sumário de mudanças:
# - Alias dos métodos: initialize, create_command_window e
# update_command_selection.
#==============================================================================

class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # Alias da inicialização do objeto
  #--------------------------------------------------------------------------
  alias modalg_quest_jrnl_init initialize
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #  menu_index : posição inicial do cursor nos comandos
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    modalg_quest_jrnl_init (menu_index)
    return unless $game_system.quest_menuaccess
    if @menu_index == 'Quest'
      @menu_index = ModAlg_QuestData::MENU_INDEX
    elsif @menu_index >= ModAlg_QuestData::MENU_INDEX
      @menu_index += 1
    end
  end
  #--------------------------------------------------------------------------
  # Alias do criação da janela de comandos
  #--------------------------------------------------------------------------
  alias modalg_quest_journal_menu_cmmnd_win_create create_command_window
  #--------------------------------------------------------------------------
  # Criação janela de comandos
  #--------------------------------------------------------------------------
  def create_command_window
    modalg_quest_journal_menu_cmmnd_win_create
    # Se acessado pelo mapa, então não adicionar no menu
    return unless $game_system.quest_menuaccess
    c = @command_window.commands
    c.insert (ModAlg_QuestData::MENU_INDEX, ModAlg_QuestData::QUESTS_LABEL)
    width = @command_window.width
    disabled = @command_window.disabled_commands
    @command_window.dispose
    @command_window = Window_Command.new(width, c)
    @command_window.index = @menu_index
    # Desabilitar todos os antigos comandos
    disabled.each { |i|
      i += 1 if i >= ModAlg_QuestData::MENU_INDEX
      @command_window.draw_item (i, false)
    }
    if $game_system.quest_disabled || $game_party.quests.list.empty? # Se Quest Journal desabilitado
      @command_window.draw_item (ModAlg_QuestData::MENU_INDEX, false)
    end
  end
  #--------------------------------------------------------------------------
  # Alias da atualização da escolha de comando
  #--------------------------------------------------------------------------
  alias modalg_quest_journal_menu_cmmnd_select_upd update_command_selection
  #--------------------------------------------------------------------------
  # Atualização da escolha de comando
  #--------------------------------------------------------------------------
  def update_command_selection
    if $game_system.quest_menuaccess
      changed = false
      if @command_window.index == ModAlg_QuestData::MENU_INDEX && Input.trigger? (Input::C)
        if $game_system.quest_disabled || $game_party.quests.list.empty? # If Quest Journal disabled
          Sound.play_buzzer
        else
          # Abrir a janela de Quest
          Sound.play_decision
          $scene = Scene_Quest.new
        end
        return
      end
      # Se o index de comando for maior do que deveria ser, ter certeza
      if @command_window.index > ModAlg_QuestData::MENU_INDEX
        @command_window.index = (@command_window.index - 1) % @command_window.commands.size
        changed = true
      end
    end
    modalg_quest_journal_menu_cmmnd_select_upd
    return unless $game_system.quest_menuaccess
    @command_window.index = (@command_window.index + 1) % @command_window.commands.size if changed
  end
  #--------------------------------------------------------------------------
  # Alias da atualização da seleção de herói
  #--------------------------------------------------------------------------
  alias modalg_quest_jrnl_actor_selection_upd update_actor_selection
  #--------------------------------------------------------------------------
  # Atualização da seleção de herói
  #--------------------------------------------------------------------------
  def update_actor_selection
    changed = false
    if $game_system.quest_menuaccess && @command_window.index > ModAlg_QuestData::MENU_INDEX
      @command_window.index = (@command_window.index - 1) % @command_window.commands.size
      changed = true
    end
    modalg_quest_jrnl_actor_selection_upd
    return unless $game_system.quest_menuaccess
    @command_window.index = (@command_window.index + 1) % @command_window.commands.size if changed
  end
end

#==============================================================================
# Scene_Quest
#------------------------------------------------------------------------------
#  Classe que faz o processamento da tela de Quest.
#==============================================================================

class Scene_Quest < Scene_Base
  #--------------------------------------------------------------------------
  # Inicialização do objeto
  #  menu_index : posição inicial do cursor nos comandos
  #--------------------------------------------------------------------------
  def initialize(category_index = 0, quest_index = 0)
    @category_index = category_index
    @quest_index = quest_index
  end
  #--------------------------------------------------------------------------
  # Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    # Criar janelas
    @label_window = Window_QuestLabel.new
    @category_window = Window_QuestCategory.new
    @category_window.refresh (@category_index)
    @list_window = Window_QuestList.new (@category_index, @quest_index)
    @info_window = Window_QuestInfo.new
    @info_window.refresh (@list_window.quest)
    @help_window = Window_VarySizeHelp.new
    @help_window.y = Graphics.height - @help_window.height
    @help_window.set_text ('Use as setas horizontais para mudar as categorias', 1)
  end
  #--------------------------------------------------------------------------
  # Finalização
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @label_window.dispose
    @category_window.dispose
    @list_window.dispose
    @info_window.dispose
    @help_window.dispose
  end
  #--------------------------------------------------------------------------
  # Atualização da tela
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    # Desde que a única ativade possível seja da @list_window, coloque-a aqui
    @list_window.update
    if Input.trigger?(Input::B) # Se o Botão B for pressionado
      Sound.play_cancel
      # Se retornando ao menu
      if $game_system.quest_menuaccess
        $scene = Scene_Menu.new ('Quest')
      else # retornando ao mapa
        $scene = Scene_Map.new
      end
    elsif Input.trigger? (Input::C) # Se o Botão C for pressionado
      # Abrir Journal (eventualmente)
    elsif Input.trigger? (Input::LEFT) # Se apertar para esquerda
      # Tocar SE do cursor
      Sound.play_cursor
      # Atualizar janela de categoria
      @category_index = (@category_index - 1) % 4
      @category_window.refresh (@category_index)
      @list_window.refresh (@category_index)
      @info_window.refresh (@list_window.quest)
    elsif Input.trigger? (Input::RIGHT) # Se apertar para direita
      # Tocar SE do cursor
      Sound.play_cursor
      # Atualizar janela de categoria
      @category_index = (@category_index + 1) % 4
      @category_window.refresh (@category_index)
      @list_window.refresh (@category_index)
      @info_window.refresh (@list_window.quest)
    # Se rolando pelas Quests
    elsif Input.trigger? (Input::DOWN) || Input.trigger? (Input::UP)
      # Atualizar janela de informações
      @info_window.refresh (@list_window.quest)
    end
  end
end

[DeadMaker]

Pessoal vlw uff !!! Dpois d ler vairias aulas sobre scripts entendi um pouco e consigui eidtar algumas coisa e no final pegou tud direitinhu !!!!!! Podem trancar o topico !!

[rafajujuba]

Eu posso usar seu script?

[Conteúdo patrocinado]