DoubleX RMVXA Confusion Edit
Version: v1.02f
IntroductionVersion: v1.02f
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