Foros de Emudesc

Este Va En CODE Dentro de Un Spoiler

#==============================================================================
# ** Dynamic Difficulty
#------------------------------------------------------------------------------
# By:  DrakoShade
# Version 1.1
# Last Updated:  17 March, 2008
#------------------------------------------------------------------------------ 
# Version History:
# V. 1.1:  Updated the note-parsing methodology to work as described by "loam"
#          of RMXP.org.  This script's use of the Note field will no longer
#          interfere with or be confused by other notes.  Also, pointless
#          methods for the difficulty setting have been removed.
#==============================================================================
=begin
Esta Parte Es la Que Se Modifica Revisen Los Default Por Que Estan modificado a mi Manera
by Zieg xD
=end
module RPG
  class Enemy
    def get_default_gains
      @maxhp_gain = 300            #Default 50
      @maxmp_gain = 60            #Default 10
      @atk_gain   = 7.50          #Default 1.25
      @def_gain   = 7.50          #Default 1.25
      @spi_gain   = 15           #Default 2.5
      @agi_gain   = 15           #Default 2.5
      @hit_gain   =  5             #Default 0
      @eva_gain   = 5            #Default 0
      @exp_gain   = 3             #Default 0
      @gold_gain  = 15             #Default 0
      @variance   = 20            #Default 15
      @min_level  = 1             #Default 1
      @max_level  = 50            #Default 99
    end
  end
end

=begin ========================================================================
||  Using the Note Field to your advantage.                                  ||
===============================================================================
The defaults that you set above are fine if you want every single enemy in the
game to follow the same growth pattern.  If that's the case, you don't have to
use the Note field at all for this script.  If you want your enemies to grow
in different ways from one another, then the Note field is where you make it
happen.

To do anything in the Notes with this script, you will need to include two
special lines in the box:
"=begin dynamic difficulty"
"=end dynamic difficulty"
Don't put quotes around them.  Those are simply here so that this explanation
won't mess with the commenting in the script itself.
Anything that falls between those two lines will be evaluated just after the
individual enemy looks up the defaults above.  Thus, if you include

@gold_gain = 200

then that specific enemy will be worth an extra 200 gold for every level it
gains, no matter what default you have set.  If, instead, you use the line

@gold_gain *= 2

then the enemy is worth twice the gold-per-level of your standard.  If the
standard stays at 0, of course, then it's still worth 0 a level, but you
know what I mean.

===============================================================================
||  The Minimum and Maximum Levels                                           ||
===============================================================================
In the defaults, you may have noticed the defaults for @min_level and
@max_level.  A creature for which @min_level = 1 and @max_level = 99 will gain
power as long as your party's average level is above 1, and won't stop gaining
power until level 99, which can't normally be exceeded anyway.  This works
well if you intend the enemy to scale no matter what level it's encountered at,
but you can do it differently.

An enemy for which @min_level = 10, for example, will be at the power you set
in the database any time it's encountered by a party of level 10 or lower.
When said party hits level 11, that enemy will gain only 1 level, rather than
the 10 that anything else would gain.  In this way, you can create enemies that
are never incredibly weak, but still get stronger.

@max_level is similar, but for the other end of the spectrum.  An enemy for
which @max_level = 30, for instance, would scale as normal up until the party
reached that level.  but if the party were level 40, it would still only grow
as if the party were level 30.  Thus, this enemy stops gaining power when the
party's average level hits it's @max_level.

===============================================================================
||  Game Difficulty                                                          ||
===============================================================================
At any point, you can set the value of the game's difficulty with a simple
script call.  Since it's an attr_accessor, all you have to do is one of these:
$game_system.difficulty = x
$game_system.difficulty += x
$game_system.difficulty -= x
Etcetera, so on, and so forth.

This script uses the difficulty to determine the level of the enemies, mostly
like the party's average level, but with a small difference.
When setting how powerful a monster is, for its maximum HP, attack and defense,
etc. the script will add the difficulty to the party's level.  However, when
determining the rewards of experience and gold returns, the script ignores
this value.

Example:
An enemy at level 8 and game difficulty of 2 will be just as hard to beat as
the same enemy at level 10 and game difficulty 0, but will give rewards the
same as if you'd beat it at level 8 and difficulty 0.

===============================================================================
||  General Advice                                                           ||
===============================================================================
When designing your enemies, take into account the level at which you want them
to be a real challenge for your party.  Their stats should be roughly similar
to those of a party member at their @min_level wearing the equipment you'd
expect your party to have at the target level.

In this way, although the enemy scales down to match a party whose level is
lower than expected, he still fights as if he were equipped to take on the
stronger party.  The ability to defeat him will, at this point, hinge more
on your party's equipment than their level.
Of course, the act of balancing is purely up to you.  My default numbers are
set so that enemies will scale with a new actor's default gains in the
database.  You could retool them to scale with equipment as well, or factor
how well-equipped your enemy is into his stats at minimum level.  The choice
is yours.

I hope you enjoy using this script.  Happy creating.

===============================================================================
||  That's it.  On to the rest of the script.                                ||
===============================================================================
=end
#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
# The actual difficulty of the game as a whole is added into this class.
#==============================================================================
class Game_System
  attr_accessor :difficulty     #New public instance variable.
  
  #----------------------------------------------------------------------------
  # * Aliasing the Initialize method.
  #----------------------------------------------------------------------------
  alias drakoshade_dynamic_difficulty_initialize initialize
  def initialize
    drakoshade_dynamic_difficulty_initialize
    @difficulty = 0
  end
end
#==============================================================================
# End modifications to Game_System.
#==============================================================================

#==============================================================================
# ** RPG::Enemies
#------------------------------------------------------------------------------
# Most of the magic happens here.  New methods are created which allow the
# enemies to gain levels, based on a combination of both the party's average
# level and the new $game_system.difficulty.
#==============================================================================
module RPG
  class Enemy
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_accessor :base_maxhp, :base_maxmp, :base_atk, :base_def, :base_spi
    attr_accessor :base_agi, :base_hit, :base_eva, :base_exp, :base_gold
    attr_accessor :maxhp_gain, :maxmp_gain, :atk_gain, :def_gain, :spi_gain
    attr_accessor :agi_gain, :hit_gain, :eva_gain, :exp_gain, :gold_gain
    attr_accessor :min_level, :max_level
    
    #--------------------------------------------------------------------------
    # * Set_Bases
    #--------------------------------------------------------------------------
    def set_bases
      @base_maxhp, @base_maxmp = @maxhp, @maxmp
      @base_atk, @base_def = @atk, @def
      @base_spi, @base_agi = @spi, @agi
      @base_hit, @base_eva = @hit, @eva
      @base_exp, @base_gold = @exp, @gold
      get_default_gains
      eval(@note[/(?<==begin dynamic difficulty)(.*?)(?==end dynamic difficulty)/m].to_s)
    end
    
    #--------------------------------------------------------------------------
    # * Update Level
    #--------------------------------------------------------------------------
    def update_level
      levels = [([$game_party.ave_level, @max_level].min - @min_level), 0].max
      diff = $game_system.difficulty
      @maxhp = generate_stat(@base_maxhp-1, @maxhp_gain, (levels + diff)) + 1
      @maxmp = generate_stat(@base_maxmp-1, @maxmp_gain, (levels + diff)) + 1
      @atk = generate_stat(@base_atk-1, @atk_gain, (levels + diff)) + 1
      @def = generate_stat(@base_def-1, @def_gain, (levels + diff)) + 1
      @spi = generate_stat(@base_spi-1, @spi_gain, (levels + diff)) + 1
      @agi = generate_stat(@base_agi-1, @agi_gain, (levels + diff)) + 1
      @hit = generate_stat(@base_agi, @agi_gain, (levels + diff))
      @eva = generate_stat(@base_eva, @eva_gain, (levels + diff))
      @exp = generate_stat(@base_exp, @exp_gain, levels)
      @gold = generate_stat(@base_gold, @gold_gain, levels)
    end
      
    #--------------------------------------------------------------------------
    # * Generate Stat
    #--------------------------------------------------------------------------
    def generate_stat(base, gain, levels)
      result = base + (gain * levels)
      result *= (rand(@variance*2)+(100-@variance))
      result /= 100
      result = [result.to_i, 0].max
      return result
    end
  end
end

#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
# I'm adding a method here that will allow this script (or any other) to
# determine the average party level.
#==============================================================================
class Game_Party
  def ave_level
    level = 0
    for i in @actors
      actor = $game_actors[i]
      level += actor.level
    end
    level /= @actors.size
    return level.round
  end
end

#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
# Methods that load the database need to be altered so that the enemies set
# their bases.
#==============================================================================
class Scene_Title
  #----------------------------------------------------------------------------
  # *Alias the Load Database method.
  #----------------------------------------------------------------------------
  alias drakoshade_dynamic_difficulty_load_database load_database
  def load_database
    drakoshade_dynamic_difficulty_load_database
    for i in 1...$data_enemies.size
      $data_enemies[i].set_bases
    end
  end
  
  #----------------------------------------------------------------------------
  # *Alias the Load Battle Test Database method.
  #----------------------------------------------------------------------------
  alias drakoshade_dynamic_difficulty_load_bt_database load_bt_database
  def load_bt_database
    drakoshade_dynamic_difficulty_load_bt_database
    for i in 1...$data_enemies.size
      $data_enemies[i].set_bases
    end
  end
end

#==============================================================================
# ** Game_Troop
#------------------------------------------------------------------------------
# The modification here allows for greater versitility than modifying the
# battle scene in this situation.  Enemies will load into the troop with
# updated stats.
#==============================================================================
class Game_Troop
  #----------------------------------------------------------------------------
  # *Alias the Setup method.
  #----------------------------------------------------------------------------
  alias drakoshade_dynamic_difficulty_setup setup
  def setup(troop_id)
    for i in 1...$data_enemies.size
      $data_enemies[i].update_level
    end
    drakoshade_dynamic_difficulty_setup(troop_id)
  end
end

#-------------------------------------------------------------------------------#
# *                 Moon's Fast skill script.
#-------------------------------------------------------------------------------#
#     Yousing this script will help the player to choose his skills faster.
# ============================================================================= #

#-------------------------------------------------------------------------------#
#                          Modifying part                                       #
#-------------------------------------------------------------------------------#
module Moon
  module Window_ActorCommand
    Change_Key = Input::X  #~  The key used to switch from Fast to 
                           #~  Normal skill command
                           
    No_Skills = "No Skills" #~   Text displayed when the actor has no skills
    
    Default_Fast_skill = false #~  The battle starts with Fast 
                              #~  skill turned On if this is true
                              
    Help_window = true #~   Will the help window appear?
  end
end
#-------------------------------------------------------------------------------#
#                          Modifying part End                                   #
#-------------------------------------------------------------------------------#

#==============================================================================
# ** Window_ActorCommand
#------------------------------------------------------------------------------
#  This window is used to select actor commands, such as "Attack" or "Skill".
#==============================================================================
class Window_ActorCommand < Window_Command
  attr_accessor  :index
  attr_accessor  :fastskill
  attr_accessor  :need_refresh
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias initialize_moon_fast_skill_actor_command initialize
  def initialize
    initialize_moon_fast_skill_actor_command
    if Moon::Window_ActorCommand::Help_window
      @help_window = Window_Help.new
      @help_window.visible = false
    end
    @fastskill = Moon::Window_ActorCommand::Default_Fast_skill
    @need_refresh = false
  end
  #--------------------------------------------------------------------------
  # * Setup
  #     actor : actor
  #--------------------------------------------------------------------------
  alias setup_moon_actor_command setup
  def setup(actor)
    setup_second_part(actor)
    setup_moon_actor_command(actor)
    @need_refresh = true
  end
  #--------------------------------------------------------------------------
  # * Setup 2 - new function added in the old one
  #--------------------------------------------------------------------------
  def setup_second_part(actor)
    if ( Moon::Window_ActorCommand::Help_window ) and
      ( !@help_window.visible and @fastskill )
      @help_window.visible = true
      update_help
    end
    @actor = actor
    a = @actor.skills.size / 4
    a += @actor.skills.size % 4
    c=0
    @data_skills = {}
    for i in 1..(a+1)
      for j in 0..3
        if !@actor.skills[c].nil?
          key = [i,j+1]
          @data_skills[key] = @actor.skills[c]
          c+=1
         end
      end
    end
    @last_data_skill = @actor.skills[c-1]
    @SM = @actor.skills.size - 1 # Skill maximum size
    @screen_index1 = 1  
    @screen_index2 = 1
    @skill_index_id = @data_skills[[1,1]].id
    @command2 = Moon::Window_ActorCommand::No_Skills
  end
  
  alias dispose_moon_actor_command_fast dispose
  def dispose
    @help_window.dispose  
    dispose_moon_actor_command_fast 
  end
  #--------------------------------------------------------------------------
  # * Update - checking if the script needs a refresh
  #--------------------------------------------------------------------------
  alias update_moon_actorcommand_fast_skill update
  def update
    if Moon::Window_ActorCommand::Help_window
      if @index == 1 and @fastskill
        @help_window.visible = self.active 
      else 
        @help_window.visible = false
      end
    end
    if @need_refresh
      refresh 
      @need_refresh = false
    end
    update_moon_actorcommand_fast_skill
  end
  #--------------------------------------------------------------------------
  # * Refresh - New Refresh function
  #--------------------------------------------------------------------------
  def refresh
    if ( Moon::Window_ActorCommand::Help_window ) and 
      ( @fastskill and !@help_window.nil? )
      update_help
    end
    if !@help_window.nil?
      if ( Moon::Window_ActorCommand::Help_window ) and
        ( @help_window.visible and !@fastskill )
        @help_window.visible = false
      end
    end
    self.contents.clear
    for i in 0...@item_max
      if @fastskill and i == 1 and !@data_skills[[1,1]].nil?
        draw_fast_skill(i)
      else
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Move cursor right
  #     wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_right(wrap = false)
    if @index == 1 and @fastskill
      if @data_skills[[@screen_index2,@screen_index1]] != @last_data_skill 
        @screen_index1 += 1
        if @screen_index1 > 4
          @screen_index1 = 1
          @screen_index2 += 1
        end
      else
        Sound.play_buzzer
      end
      @need_refresh = true
    end
  end
  #--------------------------------------------------------------------------
  # * Move cursor left
  #     wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_left(wrap = false)
    if @index == 1 and @fastskill
      if @screen_index1 * @screen_index2 > 1
      @screen_index1 -= 1
      if @screen_index1 < 1
        @screen_index1 = 4
        @screen_index2 -= 1
      end
      else
      Sound.play_buzzer
      end
      @need_refresh = true
    end
  end
  #--------------------------------------------------------------------------
  # * Fast skills - gets the skill that is going to be used
  #--------------------------------------------------------------------------
  def fastskills
    skill = @data_skills[[@screen_index2, @screen_index1]] 
    return skill
  end
  #--------------------------------------------------------------------------
  # * Draw_fast_skill
  #     index : Index used for the Lines. 0 - Attack, 1 - Skill, 2 - Defense,
  #     3 - Item
  #--------------------------------------------------------------------------
  def draw_fast_skill(s)
    rect = item_rect(s)
    for i in 1..4
      if i * @screen_index2 <= @SM and !@data_skills[[@screen_index2,i]].nil?
        skill = @data_skills[[@screen_index2,i]]
        enabled = 0
        enabled += 1 if @actor.skill_can_use?(skill)
        enabled += 2 if @screen_index1 == i
        rect.x = 24*(i-1)
        self.contents.clear_rect(rect)
        draw_icon(skill.icon_index, rect.x, rect.y, enabled)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New Draw Item function
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    rect.x += 4
    rect.width -= 8
    command = @commands[index]
    command = @command2 if index == 1 and !@data_skills[[1,1]] and @fastskill
    self.contents.clear_rect(rect)
    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(rect, command)
  end
  #--------------------------------------------------------------------------
  # * Draw icon
  #     icon_index - index of the icon
  #     x - x coordinates
  #     y - y coordinates
  #     enabled - opacity style. Opacity can be in the range 0-255.
  #         0 - 64  (for not enabled, and not selected skills)
  #         1 - 128 (for enabled, and not selected skills)
  #         2 - 192 (for not enabled, but selected skills)
  #         3 - 255 (for enabled, and selected skills)
  #--------------------------------------------------------------------------
  def draw_icon(icon_index, x, y, enabled = 3)
    bitmap = Cache.system("Iconset")
    case enabled
    when 0 
      alpha = 64
    when 1
      alpha = 128
    when 2
      alpha = 192
    when 3
      alpha = 255
    end
    rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
    self.contents.blt(x, y, bitmap, rect, alpha)
  end
  #--------------------------------------------------------------------------
  # * Update Help Text
  #--------------------------------------------------------------------------
  def update_help
      skill = @data_skills[[@screen_index2,@screen_index1]]
    if @index == 1 and !skill.nil?
      desc = skill.description
      mp_c = skill.mp_cost
      @help_window.set_text(skill == nil ? "" : "#{skill.name}:#{mp_c}MP - #{desc}" )
    else
      @help_window.visible = false
    end
  end
end

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================
class Scene_Battle < Scene_Base
  alias update_moon_window_actorcommand_fast_skill update
  def update
    update_moon_window_actorcommand_fast_skill
    if ( Input.trigger?(Moon::Window_ActorCommand::Change_Key) ) and 
      ( @skill_window.nil? and !@party_command_window.active )
      if @actor_command_window.fastskill
        @actor_command_window.fastskill = false
        @actor_command_window.need_refresh = true
      else
        @actor_command_window.index = 1
        @actor_command_window.fastskill = true
        @actor_command_window.need_refresh = true
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Acotr Command Selection
  #--------------------------------------------------------------------------
  alias update_actor_command_selection_moon_actor_command_fast_skill update_actor_command_selection
  def update_actor_command_selection
    if Input.trigger?(Input::B) 
      if @target_enemy_window != nil
        Sound.play_cancel
        end_target_enemy_selection
        return
      elsif @target_actor_window != nil
        Sound.play_cancel
        end_target_actor_selection
      else 
        Sound.play_cancel
        prior_actor
      end
    else
    update_actor_command_selection_moon_actor_command_fast_skill
    end
  end
  #--------------------------------------------------------------------------
  # * Start Skill Selection
  #--------------------------------------------------------------------------
  alias start_skill_selection_moon_actorcommand_fast_skill start_skill_selection
  def start_skill_selection
    if @actor_command_window.fastskill
      @skill = @actor_command_window.fastskills
      @active_battler.last_skill_id = @skill.id if !@skill.nil?
      if @active_battler.skill_can_use?(@skill)
        Sound.play_decision
        determine_skill
      else
        Sound.play_buzzer
      end
      return
    end
    start_skill_selection_moon_actorcommand_fast_skill
  end
  #--------------------------------------------------------------------------
  # * Confirm Skill
  #--------------------------------------------------------------------------
  alias determine_skill_moon_actorcommand_fast_skill determine_skill
  def determine_skill
    if @actor_command_window.fastskill
      @active_battler.action.set_skill(@skill.id)
      if @skill.need_selection?
        if @skill.for_opponent?
          start_target_enemy_selection
        else
          start_target_actor_selection
        end
      else
        next_actor
      end
      return
    end
    determine_skill_moon_actorcommand_fast_skill
  end
  #--------------------------------------------------------------------------
  # * Next actor: refreshing the fast skill. 
  #--------------------------------------------------------------------------
  alias next_actor_moon_actor_command_fast_skill next_actor
  def next_actor
    @actor_command_window.need_refresh = true 
    next_actor_moon_actor_command_fast_skill
  end
end

  alias setup_moon_actor_command setup