DoubleX RMVXA Confusion Edit

[DoubleX]

DoubleX RMVXA Confusion Edit
Version: v1.02f

Introduction

If a battler has inflicted states with restrictions "attack an enemy", "attack anyone" or "attack an ally", he/she/it'll attack the respective targets via autobattle like actions with the autobattle flag unchanged.
This is done by reversing his/her/its identifications of allies and enemies(allies are identified as enemies and vice versa) with 50% and 100% chance with "attack anyone" and "attack an ally" respectively.
The battler won't just use "Attack"(skill #1), but instead will use all available skills. Actors will randomly pick actions as if they've autobattle flags; Enemies will pick actions according to their action patterns.

Features

* Use of notetags(requires knowledge of notetag usage) to set specific states with those restrictions to have the edited confusion effects
* A way to set all states with those restrictions to have edited confusion effects without using notetags(and ignoring them)

Screenshots





Script

"script"

Code:

#==============================================================================|
#  ** DoubleX RMVXA Confusion Edit v1.02f                                      |
#------------------------------------------------------------------------------|
#  * Changelog                                                                 |
#    v1.02f(GMT 0200 6-6-2020):                                                |
#    - Fixed actions having no targets not executing bug                       |
#    v1.02e(GMT 0100 13-8-2015):                                               |
#    - Fixed some syntax errors and typos                                      |
#    v1.02d(GMT 1400 7-7-2015):                                                |
#    - Improved this script's efficiency and readability                       |
#    v1.02c(GMT 0000 2-6-2014):                                                |
#    - Fixed bugs on adding stuff other than damage in custom damage formula   |
#    v1.02b(GMT 0300 22-3-2014):                                               |
#    - Fixed bugs on <exclude self> notetag implementations                    |
#    v1.02a(GMT 0600 21-3-2014):                                               |
#    - Added <exclude self> notetag                                            |
#    v1.01b(GMT 0000 17-1-2014):                                               |
#    - Methods are aliased rather than rewritten                               |
#    v1.01a(GMT 0000 3-1-2014):                                                |
#    - Added <confusion edit> notetag to enable confusion edit for states      |
#    v1.00a(GMT 1600 1-1-2014):                                                |
#    - 1st version of this script finished                                     |
#------------------------------------------------------------------------------|
#  * Author                                                                    |
#    DoubleX                                                                   |
#------------------------------------------------------------------------------|
#  * Terms of use                                                              |
#    None other than not claiming this script as created by anyone except      |
#    DoubleX or his alias                                                      |
#------------------------------------------------------------------------------|
#  * Prerequisites                                                             |
#    Scripts:                                                                  |
#    - none                                                                    |
#    Knowledge:                                                                |
#    - Use of notetags(v1.01a+)                                                |
#------------------------------------------------------------------------------|
#  * Functions                                                                 |
#    - Alters the effect of restrictions Attack Enemy, Attack Anyone and Attack|
#      Ally to be merely reversing the identification of allies and enemies    |
#------------------------------------------------------------------------------|
#  * Manual                                                                    |
#    To use this script, open the script editor and put this script into an    |
#    open slot between ▼ Materials and ▼ Main. Save to take effect.            |
#------------------------------------------------------------------------------|
#  * Compatibility                                                             |
#    Scripts aliasing or rewriting method:                                     |
#    - evaluate_item_with_target, friends_unit, opponents_unit, prepare,       |
#      valid?, make_targets, confusion_target, targets_for_opponents or        |
#      targets_for_friends under class Game_Action                             |
#    - make_actions under class Game_Actor                                     |
#    may have compatibility issues with this script                            |
#    Place this script above those aliasing any of these methods if possible   |
#==============================================================================|

($imported ||= {})["DoubleX RMVXA Confusion Edit"] = true

#==============================================================================|
#  ** You only need to edit this part as it's about what this script does      |
#------------------------------------------------------------------------------|

#------------------------------------------------------------------------------|
#  * (v1.01a+)Notetag <confusion edit> for states                              |
#    To make a state with those restrictions have edited confusion effects, put|
#    the above notetag into that state's notebox in the database.              |
#------------------------------------------------------------------------------|
#  * (v1.02a+)Notetag <exclude self> for states                                |
#    To make battlers with an edited confusion state never target themselves,  |
#    put the above notetag into that state's notebox in the database.          |
#    This noteag only works on skills picking a single non-random target       |
#------------------------------------------------------------------------------|

module DoubleX_RMVXA
  module Confusion_Edit

#------------------------------------------------------------------------------|
#  * (v1.01a+)Always_Confusion_Edit, default = false                           |
#    Notetags will be ignored and all states with those restrictions will have |
#    the edited confusion effects if Always_Confusion_Edit is true             |
#------------------------------------------------------------------------------|
  Always_Confusion_Edit = false

#------------------------------------------------------------------------------|
#  * (v1.02a+)Always_Exclude_Self, default = false                             |
#    Notetags will be ignored and all states with those restrictions will stop |
#    the battlers from targeting themselves if Always_Exclude_Self is true     |
#    This setting only works on skills picking a single non-random target      |
#------------------------------------------------------------------------------|
  Always_Exclude_Self = false

  end # Confusion_Edit
end # DoubleX_RMVXA

#==============================================================================|

#==============================================================================|
#  ** You need not edit this part as it's about how this script works          |
#------------------------------------------------------------------------------|

class << DataManager

  #----------------------------------------------------------------------------|
  #  Alias method: load_database                                               |
  #----------------------------------------------------------------------------|
  alias load_database_confusion_edit load_database
  def load_database
    load_database_confusion_edit
    # Added to load confusion notetags
    load_notetags_confusion_edit
    #
  end # load_database

  #----------------------------------------------------------------------------|
  #  New method: load_notetags_confusion_edit                                  |
  #----------------------------------------------------------------------------|
  def load_notetags_confusion_edit
    $data_states.each { |obj| obj.load_notetags_confusion_edit if obj }
  end # load_notetags_confusion_edit

end # DataManager

class RPG::State < RPG::BaseItem

  #----------------------------------------------------------------------------|
  #  New public instance variable                                              |
  #----------------------------------------------------------------------------|
  attr_accessor :confusion_edit
  attr_accessor :exclude_self

  #----------------------------------------------------------------------------|
  #  New method: load_notetags_confusion_edit                                  |
  #----------------------------------------------------------------------------|
  def load_notetags_confusion_edit
    @confusion_edit = @exclude_self = false
    unless (ce = DoubleX_RMVXA::Confusion_Edit) && ce::Always_Exclude_Self
      @note.split(/[\r\n]+/).each { |line|
        case line
          when /<(?:CONFUSION_EDIT|confusion edit)>/i
            @confusion_edit = true
          when /<(?:EXCLUDE_SELF|exclude self)>/i
            @exclude_self = true
          end
          break if @confusion_edit && @exclude_self
      }
    end
    @confusion_edit ||= ce::Always_Confusion_Edit
    @exclude_self ||= ce::Always_Exclude_Self
  end # load_notetags_confusion_edit

end # RPG::State

class Game_Action

  #----------------------------------------------------------------------------|
  #  (v1.02c+)Rewrite method: evaluate_item_with_target                        |
  #----------------------------------------------------------------------------|
  def evaluate_item_with_target(target)
    target.result.clear
    # Rewritten to prevent executing any custom damage formula stuff
    eval_target = Marshal.load( Marshal.dump(target) )
    eval_subject = Marshal.load( Marshal.dump(subject) )
    eval_target.make_damage_value(eval_subject, item)
    #
    if item.for_opponent?
      return eval_target.result.hp_damage.to_f / [eval_target.hp, 1].max
    end
    recovery = [-eval_target.result.hp_damage,
    eval_target.mhp - eval_target.hp].min.to_f / eval_target.mhp
  end # evaluate_item_with_target

  #----------------------------------------------------------------------------|
  #  (v1.02d+)Alias method: initialize                                         |
  #----------------------------------------------------------------------------|
  alias initialize_confusion_edit initialize
  def initialize(subject, forcing = false)
    initialize_confusion_edit(subject, forcing)
    # Added to initializes the array storing all targets selected by this script
    @targets_confusion_edit = []
    #
  end # initialize

  #----------------------------------------------------------------------------|
  #  Alias method: friends_unit                                                |
  #----------------------------------------------------------------------------|
  alias friends_unit_confusion_edit friends_unit
  def friends_unit
    # Rewritten to use confusion edit if subject.confusion_edit is true
    friends_opponents_unit("friends", "opponents")
    #
  end # friends_unit

  #----------------------------------------------------------------------------|
  #  Alias method: opponents_unit                                              |
  #----------------------------------------------------------------------------|
  alias opponents_unit_confusion_edit opponents_unit
  def opponents_unit
    # Rewritten to use confusion edit if subject.confusion_edit is true
    friends_opponents_unit("opponents", "friends")
    #
  end # opponents_unit

  #----------------------------------------------------------------------------|
  #  Alias method: prepare                                                     |
  #----------------------------------------------------------------------------|
  alias prepare_confusion_edit prepare
  def prepare
    # Rewritten to use confusion edit if subject.confusion_edit is true
    prepare_confusion_edit unless subject.confusion_edit?(subject.states)
    #
  end # prepare

  #----------------------------------------------------------------------------|
  #  (v1.02a+)Alias method: valid?                                             |
  #----------------------------------------------------------------------------|
  alias valid_confusion_edit? valid?
  def valid?
    # Rewritten to use confusion edit if subject.confusion_edit is true
    @targets_confusion_edit = []
    return false unless valid_confusion_edit?
    !item.for_opponent? && !item.for_friend? || !make_targets.empty?
    #
  end # valid?

  #----------------------------------------------------------------------------|
  #  Alias method: make_targets                                                |
  #----------------------------------------------------------------------------|
  alias make_targets_confusion_edit make_targets
  def make_targets
    # Rewritten to use confusion edit if subject.confusion_edit is true
    return @targets_confusion_edit unless @targets_confusion_edit.empty?
    if subject.confusion_edit?(subject.states)
      return targets_for_opponents if item.for_opponent?
      return targets_for_friends if item.for_friend?
      return []
    end
    unless forcing || subject.confusion_level != 3 ||
    friends_unit.alive_members.size > 1
      return []
    end
    make_targets_confusion_edit
    #
  end # make_targets

  #----------------------------------------------------------------------------|
  #  (v1.02b+)Alias method: confusion_target                                   |
  #----------------------------------------------------------------------------|
  alias confusion_target_confusion_edit confusion_target
  def confusion_target
    # Rewritten to exclude self if there's exclude self notetag
    target = confusion_target_confusion_edit
    unless subject.exclude_self?(subject.states) && target == subject
      return target
    end
    target = confusion_target_confusion_edit while target == subject
    target
    #
  end # confusion_target

  #----------------------------------------------------------------------------|
  #  (v1.02a+)Alias method: targets_for_opponents                              |
  #----------------------------------------------------------------------------|
  alias targets_for_opponents_confusion_edit targets_for_opponents
  def targets_for_opponents
    # Rewritten to exclude self if there's exclude self notetag
    confusion_edit_targets("opponents")
    #
  end # targets_for_opponents

  #----------------------------------------------------------------------------|
  #  (v1.02a+)Alias method: targets_for_friends                                |
  #----------------------------------------------------------------------------|
  alias targets_for_friends_confusion_edit targets_for_friends
  def targets_for_friends
    # Rewritten to exclude self if there's exclude self notetag
    confusion_edit_targets("friends")
    #
  end # targets_for_friends

  #----------------------------------------------------------------------------|
  #  (v1.02a+)New method: targets_for_friends_opponents                        |
  #----------------------------------------------------------------------------|
  def targets_for_friends_opponents
    num = 1
    num+ subject.atk_times_add.to_i if attack? && !item.for_friend?
    return [friends_unit.random_target] * num if rand(2) == 0
    [opponents_unit.random_target] * num
  end # targets_for_friends_opponents

  #----------------------------------------------------------------------------|
  #  (v1.02a+)New method: confusion_edit_targets                               |
  #----------------------------------------------------------------------------|
  def confusion_edit_targets(targets)
    return [] if item.for_user? && subject.exclude_self?(subject.states)
    init_confusion_edit_targets(targets)
    return @targets_confusion_edit unless @targets_confusion_edit.empty?
    return @targets_confusion_edit if item.for_dead_friend?
    if subject.confusion_level == 1 && item.for_friend? &&
    freinds_unit.alive_members.size <= 1
      return @targets_confusion_edit
    end
    if subject.confusion_level == 3 && item.for_opponent? &&
    opponents_unit.alive_members.size <= 1
      return @targets_confusion_edit
    end
    loop_confusion_edit_targets(targets)
    @targets_confusion_edit
  end # confusion_edit_targets

  #----------------------------------------------------------------------------|
  #  (v1.02d+)New method: init_confusion_edit_targets                          |
  #----------------------------------------------------------------------------|
  def init_confusion_edit_targets(targets)
    if subject.confusion_level == 2 && item.for_one? && !item.for_dead_friend?
      @targets_confusion_edit = targets_for_friends_opponents
    else
      @targets_confusion_edit =
      send("targets_for_#{targets}_confusion_edit".to_sym)
    end
    return unless item.for_one? && subject.exclude_self?(subject.states)
    return unless @targets_confusion_edit.include?(subject)    
    @targets_confusion_edit.delete(subject)
  end # init_confusion_edit_targets

  #----------------------------------------------------------------------------|
  #  (v1.02d+)New method: loop_confusion_edit_targets                          |
  #----------------------------------------------------------------------------|
  def loop_confusion_edit_targets(targets)
    begin
      @target_index = -1
      if subject.confusion_level == 2
        @targets_confusion_edit = targets_for_friends_opponents
      else
        @targets_confusion_edit =
        send("targets_for_#{targets}_confusion_edit".to_sym)
      end
      next unless @targets_confusion_edit.include?(subject)
      @targets_confusion_edit.delete(subject)
    end while @targets_confusion_edit.empty?
  end # loop_confusion_edit_targets

  #----------------------------------------------------------------------------|
  #  (v1.02a+)New method: friends_opponents_unit                               |
  #----------------------------------------------------------------------------|
  def friends_opponents_unit(friends, opponents)
    if !forcing && subject.confusion_edit?(subject.states)
      case subject.confusion_level
      when 1
        return send("#{friends}_unit_confusion_edit".to_sym)
      when 2
        return send("#{friends}_unit_confusion_edit".to_sym) if rand(2) == 0
        return send("#{opponents}_unit_confusion_edit".to_sym)
      end
      send("#{opponents}_unit_confusion_edit".to_sym)
    else
      send("#{friends}_unit_confusion_edit".to_sym)
    end
  end # friends_opponents_unit

end # Game_Action

class Game_BattlerBase

  #----------------------------------------------------------------------------|
  #  New method: confusion_edit?                                               |
  #----------------------------------------------------------------------------|
  def confusion_edit?(state)
    return false unless confusion? && state
    state.each { |s| return true if s.confusion_edit }
    false
  end # confusion_edit?

  #----------------------------------------------------------------------------|
  #  (v1.02a+)New method: exclude_self?                                        |
  #----------------------------------------------------------------------------|
  def exclude_self?(state)
    return false unless confusion? && state
    state.each { |s| return true if s.exclude_self }
    false
  end # exclude_self?

end # Game_BattlerBase

class Game_Actor < Game_Battler

  #----------------------------------------------------------------------------|
  #  Alias method: make_actions                                                |
  #----------------------------------------------------------------------------|
  alias make_actions_confusion_edit make_actions
  def make_actions
    # Rewritten to use confusion edit if subject.confusion_edit is true
    return make_actions_confusion_edit unless confusion_edit?(states)
    super
    make_auto_battle_actions
    #
  end # make_actions

end # Game_Actor

#==============================================================================|

Instructions

Open the script editor and put this script into an open slot between Materials and Main. Save to take effect.

FAQ

None

Compatibility

Scripts aliasing or rewriting method:
- friends_unit, opponents_unit, prepare or make_targets under class Game_Action
- make_actions under class Game_Actor
may have compatibility issues with this script
Place this script above those aliasing any of these methods if possible

Credits and Thanks

None

Author's Notes

None

Terms and Conditions

None other than not claiming this script as created by anyone except DoubleX or his alias