[VX / VXAce] Zasady zwycięstwa

Spoiler: (Otwórz)
Kod:

=begin

#===============================================================================​

 Title: Battle Rules

 Author: Tsukihime

 Date: May 4, 2013

--------------------------------------------------------------------------------

 ** Change log

 May 4, 2013

   - victory/defeat condition check methods dynamically generated now

   - added support for modifying default rules

   - Initial release

--------------------------------------------------------------------------------   

 ** Terms of Use

 * Free to use in commercial/non-commercial projects

 * No real support. The script is provided as-is

 * Will do bug fixes, but no compatibility patches

 * Features may be requested but no guarantees, especially if it is non-trivial

 * Credits to Tsukihime in your project

 * Preserve this header

--------------------------------------------------------------------------------

 ** Description

 This script allows you to set up "battle rules" for victory or

 defeat. The default battle rules are

   default victory rules: all enemies are dead

   default defeat rules: all actors are dead

 There are four scopes for battle rules

 * Global battle rules

   These apply to all battles. These are the "default" rules.

 * Map battle rules

   These apply to all battles that occur on the current map

 * Troop battle rules

   These apply to any encounter with this troop.

 * Event battle rules

   These apply to encounters on a per-event basis

 There are two ways to specify rules for a battle

 1. Set rules. These overwrite any previous rules. So for example, if you had

    defined map rules and troop rules, but then have "set" event rules, then

    all of the map rules and troop rules will not apply for this battle.

 2. Add rules. These are added on top of any previous rules, so you can add

    event battle rules to any troop rules or map rules.

--------------------------------------------------------------------------------

 ** Installation

 Place this script below Materials and above Main

--------------------------------------------------------------------------------

 ** Usage

 All rules use the same syntax as follows:

   <victory rule: add>

     cond: some victory condition

     desc: some description

   </victory rule>

   <defeat rule: set>

     cond: some defeat condition

     desc: some description

   </defeat rule>

 `cond` is the condition of this rule, as a ruby statement that evaluates to

 true or false.

 `desc` is a description of this rule. This is not necessary, but maybe some

 other scripts will find some use for it.

 Add and set types apply to both victory and defeat rules. They are just

 example syntax.

 For maps, they will be written in the note-box

 For troops and events they will be written as comments.

 All rules must be satisfied in order for a victory or defeat condition to be

 met, so if you have 3 victory rules, then you must meet all 3 rules in order

 to win a battle.

 In the configuration, you can set up the default rules and their descriptions.

--------------------------------------------------------------------------------

 ** Compatibility

 This script overwrites the following method:

   BattleManager

     self.judge_win_loss

#===============================================================================​

=end

$imported = {} if $imported.nil?

$imported["TH_BattleRules"] = true

#===============================================================================​

# ** Configuration

#===============================================================================​

module TH

  module Battle_Rules

    # You can set the default rules here. 

    # Format: condition => description

    Default_Victory_Rules = {

      "$game_troop.all_dead?" => "All enemies defeated"

    }

    Default_Defeat_Rules = {

      "$game_party.all_dead?" => "All allies defeated"

    }

#===============================================================================​

# ** Rest of Script

#===============================================================================​

    Victory_Regex = /<victory rule: (\w+)>(.*?)<\/victory rule>/im

    Defeat_Regex = /<defeat rule: (\w+)>(.*?)<\/defeat rule>/im

    #---------------------------------------------------------------------------

    # Returns all battle rules

    #---------------------------------------------------------------------------

    def battle_rules

      return @battle_rules unless @battle_rules.nil?

      parse_battle_rules

      return @battle_rules

    end

    #---------------------------------------------------------------------------

    # Go through each set of options and store them appropriately

    #---------------------------------------------------------------------------

    def parse_battle_rule_options(rule, data)

      data.each do |tag|

        name, value = tag.split(":")

        case name.downcase

        when "cond"

          rule.condition = value

        when "desc"

          rule.description = value

        end

      end

    end

    #---------------------------------------------------------------------------

    # Adds new rule to the battle rules based on the rule category and rule type

    #---------------------------------------------------------------------------

    def add_battle_rule(rule, category, type)

      case category

      when :victory

        case type.downcase

        when "set"

          @battle_rules.set_victory_rule(rule)

        when "add"

          @battle_rules.add_victory_rule(rule)

        end

      when :defeat

        case type.downcase

        when "set"

          @battle_rules.set_defeat_rule(rule)

        when "add"

          @battle_rules.add_defeat_rule(rule)

        end

      end

    end

    def parse_battle_rule_comments(comments)

      comments.each do |comment|

        # check victory rules

        if comment =~ Victory_Regex

          rule = Game_BattleRule.new

          data = $2.strip.split("\r\n")

          parse_battle_rule_options(rule, data)

          add_battle_rule(rule, :victory, $1)

        end

        # check defeat rules

        if comment =~ Defeat_Regex

          rule = Game_BattleRule.new

          data = $2.strip.split("\r\n")

          parse_battle_rule_options(rule, data)

          add_battle_rule(rule, :defeat, $1)

        end

      end

    end

    #---------------------------------------------------------------------------

    # Collect all comments from an event page. Only applies to events.

    #---------------------------------------------------------------------------

    def comments

      coms = []

      comment = ""

      @list.each do |cmd|

        if cmd.code == 108

          coms << comment unless comment.empty?

          comment = cmd.parameters[0]

        elsif cmd.code == 408

          comment << "\r\n" << cmd.parameters[0]

        end

      end

      coms << comment

      coms

    end

  end

end

module RPG

  class Map

    include TH::Battle_Rules

    def parse_battle_rules

      @battle_rules = Game_BattleRules.new

      victory_rules = self.note.scan(Victory_Regex)

      victory_rules.each do |res|

        rule = Game_BattleRule.new

        data = res[1].strip.split("\r\n")        

        parse_battle_rule_options(rule, data)

        add_battle_rule(rule, :victory, res[0])

      end

      defeat_rules = self.note.scan(Defeat_Regex)

      defeat_rules.each do |res|

        rule = Game_BattleRule.new

        data = res[1].strip.split("\r\n")        

        parse_battle_rule_options(rule, data)

        add_battle_rule(rule, :defeat, res[0])

      end

    end 

  end

  class Troop

    include TH::Battle_Rules

    #---------------------------------------------------------------------------

    # Search all pages for battle rules

    #---------------------------------------------------------------------------

    def parse_battle_rules

      @battle_rules = Game_BattleRules.new

      all_comments = []

      @pages.each do |page|

        all_comments << page.comments

      end

      all_comments.flatten!

      parse_battle_rule_comments(all_comments)

    end

  end

  class Troop::Page

    include TH::Battle_Rules

  end

  class Event::Page

    include TH::Battle_Rules

    def parse_battle_rules

      @battle_rules = Game_BattleRules.new

      parse_battle_rule_comments(comments)

    end

  end

end

module BattleManager

  class << self

    alias :th_battle_rules_setup :setup

  end

  #-----------------------------------------------------------------------------

  # Setup battle rules

  #-----------------------------------------------------------------------------

  def self.setup(troop_id, can_escape = true, can_lose = false)

    th_battle_rules_setup(troop_id, can_escape, can_lose)

    setup_battle_rules

  end

  #-----------------------------------------------------------------------------

  # Overwrite. Now we have more conditions available.

  #-----------------------------------------------------------------------------

  def self.judge_win_loss

    if @phase

      return process_abort   if $game_party.members.empty?

      return process_defeat  if defeat_conditions_met?

      return process_victory if victory_conditions_met?

      return process_abort   if aborting?

    end

    return false

  end

  #-----------------------------------------------------------------------------

  # New.

  #-----------------------------------------------------------------------------

  def self.setup_battle_rules

    setup_victory_conditions

    setup_defeat_conditions

  end

  #-----------------------------------------------------------------------------

  # New.

  #-----------------------------------------------------------------------------

  def self.setup_victory_conditions

    # If event has "set" rules, then overwrite base rules

    if !$game_temp.battle_rules.set_victory_rules.empty?

      @victory_conditions = $game_temp.battle_rules.set_victory_rules

    # If troop has "set" rules, then overwrite map rules

    elsif !$game_troop.battle_rules.set_victory_rules.empty?

      @victory_conditions = $game_troop.battle_rules.set_victory_rules

    # If map has "set" rules, then overwrite default rules

    elsif !$game_map.battle_rules.set_victory_rules.empty?

      @victory_conditions = $game_map.battle_rules.set_victory_rules

    # Otherwise just use default rules

    else

      @victory_conditions = $game_system.battle_rules.default_victory_rules

    end

    # now add the "add" rule

    @victory_conditions.concat($game_map.battle_rules.add_victory_rules)

    @victory_conditions.concat($game_troop.battle_rules.add_victory_rules)

    @victory_conditions.concat($game_temp.battle_rules.add_victory_rules)

    # Generate the victory condition checking method

    define_method_victory_check

  end

  #-----------------------------------------------------------------------------

  # New. Analogous to victory rules.

  #-----------------------------------------------------------------------------

  def self.setup_defeat_conditions

    if !$game_temp.battle_rules.set_defeat_rules.empty?

      @defeat_conditions = $game_temp.battle_rules.set_defeat_rules

    elsif !$game_troop.battle_rules.set_defeat_rules.empty?

      @defeat_conditions = $game_troop.battle_rules.set_defeat_rules

    elsif !$game_map.battle_rules.set_defeat_rules.empty?

      @defeat_conditions = $game_map.battle_rules.set_defeat_rules

    else

      @defeat_conditions = $game_system.battle_rules.default_defeat_rules

    end

    @defeat_conditions.concat($game_map.battle_rules.add_defeat_rules)

    @defeat_conditions.concat($game_troop.battle_rules.add_defeat_rules)

    @defeat_conditions.concat($game_temp.battle_rules.add_defeat_rules)

    define_method_defeat_check

  end

  #-----------------------------------------------------------------------------

  # Dynamically define the victory checking method to speed up performance

  #-----------------------------------------------------------------------------

  def self.define_method_victory_check

    stmt = "def self.victory_conditions_met?;"

    @victory_conditions.each_with_index {|rule, i|

      if i == 0

        stmt << "#{rule.condition}"

      else

        stmt << " && #{rule.condition}"

      end

    }

    stmt << ";end"

    eval(stmt)

  end

  #-----------------------------------------------------------------------------

  # Dynamically define the defeat checking method to speed up performance

  #-----------------------------------------------------------------------------

  def self.define_method_defeat_check

    stmt = "def self.defeat_conditions_met?;"

    @defeat_conditions.each_with_index {|rule, i|

      if i == 0

        stmt << "#{rule.condition}"

      else

        stmt << " && #{rule.condition}"

      end

    }

    stmt << ";end"

    eval(stmt)

  end

end

#-------------------------------------------------------------------------------

# Event battle rules are stored as temporary data and only used by the

# Battle Manager to set things up

#-------------------------------------------------------------------------------

class Game_Temp

  attr_accessor :battle_rules

  alias :th_battle_rules_initialize :initialize

  def initialize

    th_battle_rules_initialize

    clear_battle_rules

  end

  def clear_battle_rules

    @battle_rules = Game_BattleRules.new

  end

end

#-------------------------------------------------------------------------------

# Global battle rules are stored with the game system.

#-------------------------------------------------------------------------------

class Game_System

  attr_reader :battle_rules

  alias :th_battle_rules_initialize :initialize

  def initialize

    th_battle_rules_initialize

    clear_battle_rules

  end

  def clear_battle_rules

    @battle_rules = Game_BattleRules.new

  end

end

#-------------------------------------------------------------------------------

# A wrapper containing battle rules

#-------------------------------------------------------------------------------

class Game_BattleRules

  attr_reader :set_victory_rules

  attr_reader :add_victory_rules

  attr_reader :set_defeat_rules

  attr_reader :add_defeat_rules

  def initialize

    @set_victory_rules = []

    @add_victory_rules = []

    @set_defeat_rules = []

    @add_defeat_rules = []

  end

  def add_victory_rule(rule)

    @add_victory_rules << rule

  end

  def set_victory_rule(rule)

    @set_victory_rules << rule

  end

  def add_defeat_rule(rule)

    @add_defeat_rules << rule

  end

  def set_defeat_rule(rule)

    @set_defeat_rules << rule

  end

  def default_victory_rules

    TH::Battle_Rules::Default_Victory_Rules.inject([]) do |r, (k,v)|

      r << Game_BattleRule.new(k, v)

    end

  end

  def default_defeat_rules

    TH::Battle_Rules::Default_Defeat_Rules.inject([]) do |r, (k,v)|

      r << Game_BattleRule.new(k, v)

    end

  end

end

#-------------------------------------------------------------------------------

# A battle rule object. Contains a condition, as well as a description of the

# rule

#-------------------------------------------------------------------------------

class Game_BattleRule

  attr_accessor :condition

  attr_accessor :description

  def initialize(condition="true", description="")

    @condition = condition

    @description = description

  end

end

#-------------------------------------------------------------------------------

# Store the event's battle rules in game temp

#-------------------------------------------------------------------------------

class Game_Interpreter

  alias :th_battle_rules_command_301 :command_301

  def command_301

    $game_temp.battle_rules = $game_map.events[@event_id].battle_rules

    th_battle_rules_command_301

  end

end

#-------------------------------------------------------------------------------

# Retrieve map-level battle rules from the current map

#-------------------------------------------------------------------------------

class Game_Map

  def battle_rules

    @map ? @map.battle_rules : Game_BattleRules.new

  end

end

#-------------------------------------------------------------------------------

# Retrieve troop-level battle rules from the current map

#-------------------------------------------------------------------------------

class Game_Troop

  def battle_rules

    troop.battle_rules

  end

end

#-------------------------------------------------------------------------------

# Retrieve event-level battle rules from the current map

#-------------------------------------------------------------------------------

class Game_Event

  def battle_rules

    @page ? @page.battle_rules : Game_BattleRules.new

  end

end