Script de dinâmica de populações básica para eventos no RPG Maker VX Ace.

[RGSS3] Populations.rb

#==============================================================================
# Populations | v0.1.2 | por Masked
#
# para RPG Maker VX Ace
#------------------------------------------------------------------------------
#  Dinâmica de populações básica para eventos.
#==============================================================================

module Populations
  VERSION = [0, 1, 2].freeze
end

#==============================================================================
# ** Populations::Util
#------------------------------------------------------------------------------
#  Módulo de utilidades do script.
#==============================================================================
module Populations::Util
  #--------------------------------------------------------------------------
  # * Cópia profunda
  #     object  : Objeto a ser clonado
  #     cloned  : Hash de objetos já clonados
  #--------------------------------------------------------------------------
  def self.deep_copy(object, cloned = {})
    case object
    when Numeric, TrueClass, FalseClass, NilClass
      object
    when Array
      object.map { |item| deep_copy(item, cloned) }
    when Hash
      Hash[object.map do |key, item|
        [deep_copy(key, cloned), deep_copy(item, cloned)]
      end]
    else
      deep_copy_object(object, cloned)
    end
  end

  #--------------------------------------------------------------------------
  # * Cópia profunda de objeto
  #     object  : Objeto a ser clonado
  #     cloned  : Hash de objetos já clonados
  #--------------------------------------------------------------------------
  def self.deep_copy_object(object, cloned)
    return cloned[object] if cloned.key?(object)

    clone = object.dup
    cloned.update(object => clone)
    object.instance_variables.each do |var|
      value = object.instance_variable_get(var)
      clone.instance_variable_set(var, deep_copy(value, cloned))
    end
    clone
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Esta classe gerencia os eventos. Ela controla funções incluindo a mudança
# de páginas de event por condições determinadas, e processos paralelos.
# Esta classe é usada internamente pela classe Game_Map.
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # * Obtém um valor de comentário a partir de uma regex
  #     regex : Regexp
  #--------------------------------------------------------------------------
  def comment_config(regex)
    return nil unless list

    list.each do |command|
      next if (command.code != 108) && (command.code != 408)
      next unless command.parameters[0] =~ regex

      captures = Regexp.last_match.captures
      return captures.first if captures.size == 1

      return captures
    end
    nil
  end

  #--------------------------------------------------------------------------
  # * Obtém o número inicial de indivíduos da população
  #--------------------------------------------------------------------------
  def initial_population
    comment_config(/population size:\s*(\d+)/i).to_i
  end

  #--------------------------------------------------------------------------
  # * Obtém o valor máximo da população
  #--------------------------------------------------------------------------
  def max_population
    max = comment_config(/population max:\s*(\d+)/i)
    return max.to_i unless max.nil?

    initial_population + 1
  end

  #--------------------------------------------------------------------------
  # * Define o ID do evento
  #     id  : Novo ID
  #--------------------------------------------------------------------------
  def id=(id)
    @id = @event.id = id
  end

  #--------------------------------------------------------------------------
  # * Obtém o nome da população
  #--------------------------------------------------------------------------
  def population_name
    comment_config(/population name:\s*(.+)\s*/i)
  end

  #--------------------------------------------------------------------------
  # * Obtém o objeto da população
  #--------------------------------------------------------------------------
  def population
    name = population_name
    return nil unless name

    $game_populations[name] ||= Game_Population.new(self)
  end

  #--------------------------------------------------------------------------
  # * Obtém as regiões da população
  #--------------------------------------------------------------------------
  def population_regions
    value = comment_config(/population regions:\s+(.+)\s*/i)
    return [] unless value

    value.split(/\s*,\s*/).map(&:to_i)
  end
end

#==============================================================================
# ** Game_Population
#------------------------------------------------------------------------------
#  Esta classe gerencia as populações eventos. Ela controla a replicação de
# eventos no mapa e gerencia as flutuações na população.
#==============================================================================

class Game_Population
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :prototype
  attr_reader   :instances
  attr_reader   :size

  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     prototype : Evento base
  #--------------------------------------------------------------------------
  def initialize(prototype)
    @prototype = prototype
    @instances = []
    setup_size
  end

  #--------------------------------------------------------------------------
  # * Configuração do número de eventos da população
  #--------------------------------------------------------------------------
  def setup_size
    @size = @prototype.initial_population
    @real_size = @size.to_f
  end

  #--------------------------------------------------------------------------
  # * Cria uma população no mapa
  #--------------------------------------------------------------------------
  def spawn
    (@size - @instances.size).times do
      @instances << Populations::Util.deep_copy(prototype)
      prototype.id = (prototype.id << 16) + @instances.size
    end

    setup_instances
  end

  #--------------------------------------------------------------------------
  # * Configura as instâncias da população
  #--------------------------------------------------------------------------
  def setup_instances
    @instances.each do |event|
      setup_instance(event)
      $game_map.events[event.id] = event
    end
  end

  #--------------------------------------------------------------------------
  # * Reproduz a população
  #--------------------------------------------------------------------------
  def reproduce(r = 2.25)
    max = @prototype.max_population.to_f
    @real_size = r * (@real_size / max) * (1 - @real_size / max) * max
    @size = @real_size.round
  end

  #--------------------------------------------------------------------------
  # * Configuração de instância
  #     event : Instância
  #--------------------------------------------------------------------------
  def setup_instance(event)
    possible_positions = $game_map.xy_pairs.select do |x, y|
      @prototype.population_regions.include?($game_map.region_id(x, y))
    end
    return if possible_positions.empty?

    event.moveto(*possible_positions.sample)
  end

  #--------------------------------------------------------------------------
  # * Atualização da população
  #--------------------------------------------------------------------------
  def update
    return unless @instances.reject! { |event| event.list.nil? }

    @real_size = @size = @instances.size
  end

  #--------------------------------------------------------------------------
  # * Configuração do número de eventos da população
  #--------------------------------------------------------------------------
  def regions
    @prototype.population_regions
  end
end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Configuração
  #--------------------------------------------------------------------------
  alias setup_without_population setup

  def setup(*args)
    setup_without_population(*args)
    setup_populations
  end

  #--------------------------------------------------------------------------
  # * Configuração das populações
  #--------------------------------------------------------------------------
  def setup_populations
    @populations = []
    events.values.each do |event|
      population = event.population
      next unless population

      events.delete(event.id)
      @populations << population
      population.spawn
    end
  end

  #--------------------------------------------------------------------------
  # * Atualização da tela
  #     main : flag de atualização do interpreter
  #--------------------------------------------------------------------------
  alias update_without_population update

  def update(main = false)
    update_without_population(main)
    update_populations
  end

  #--------------------------------------------------------------------------
  # * Atualização das populações
  #--------------------------------------------------------------------------
  def update_populations
    @populations.each(&:update)
  end

  #--------------------------------------------------------------------------
  # * Pares de coordenadas do mapa
  #--------------------------------------------------------------------------
  def xy_pairs
    Enumerator.new do |enum|
      $game_map.height.times do |y|
        $game_map.width.times do |x|
          enum.yield(x, y)
        end
      end
    end
  end
end

#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
#  Este módulo gerencia o jogo e objetos do banco de dados utilizados no jogo.
# Quase todas as variáveis globais são inicializadas no módulo.
#==============================================================================

class << DataManager
  #--------------------------------------------------------------------------
  # * Criação dos objetos do jogo
  #--------------------------------------------------------------------------
  alias create_game_objects_without_populations create_game_objects

  def create_game_objects
    create_game_objects_without_populations

    $game_populations = {}
  end
  #--------------------------------------------------------------------------
  # * Salvar a criação de conteúdo
  #--------------------------------------------------------------------------
  alias make_save_contents_without_populations make_save_contents

  def make_save_contents
    contents = make_save_contents_without_populations
    contents[:populations] = $game_populations
    contents
  end

  #--------------------------------------------------------------------------
  # * Extrair conteúdo salvo
  #--------------------------------------------------------------------------
  alias extract_save_contents_without_populations extract_save_contents

  def extract_save_contents(contents)
    extract_save_contents_without_populations(contents)
    $game_populations = contents[:populations]
  end
end