#==============================================================================| # ** 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 #==============================================================================|