###--------------------------------------------------------------------------### # CP Enemy Scan script # # Version 1.2a # # # # Credits: # # Original code by: Neon Black # # Modified by: # # # # This work is licensed under the Creative Commons Attribution-NonCommercial # # 3.0 Unported License. To view a copy of this license, visit # # http://creativecommons.org/licenses/by-nc/3.0/. # # Permissions beyond the scope of this license are available at # # http://cphouseset.wordpress.com/liscense-and-terms-of-use/. # # # # Contact: # # NeonBlack - neonblack23@live.com (e-mail) or "neonblack23" on skype # ###--------------------------------------------------------------------------### ###--------------------------------------------------------------------------### # Revision information: # # V1.2a - 12.19.2013 # Quick fix for 2 issues # V1.2 - 11.12.2012 # # Added libra effect # # Recoded how discovered elements are stored/called # # Added new options and visuals # # V1.1 - 11.11.2012 # # Fixed a bug related to adding weak states # # Added pop-ups when used with battleview 1 # # V1.0 - 11.6.2012-11.9.2012 # # Wrote and debugged main script # ###--------------------------------------------------------------------------### ###--------------------------------------------------------------------------### # Compatibility: # # Alias - Game_System: initialize # # Game_Battler: item_apply, item_effect_add_state_attack, # # item_effect_add_state_normal # # Scene_Battle: create_all_windows, create_enemy_window, # # next_command, update, invoke_item # # Window_BattleEnemy: update # # New Methods - Game_System: scan_known_elements, scan_known_states, # # add_known_element, add_known_state # # Game_Battler: scan_check_rate, cp_scan_enemy, # # scan_element_affinities, scan_state_affinities, # # scan_weak_elements, scan_weak_states, # # scan_strong_elements, scan_strong_states # # Scene_Battle: create_scan_windows, open_enemy_scan, # # close_enemy_scan, next_enemy, last_enemy # # scan_windows, open_scan_window, # # close_scan_window, close_from_selection # # Window_ScanEnemy: initialize, refresh, enemy, draw_enemy_hp, # # draw_enemy_mp, draw_enemy_tp, # # process_pageup, process_pagedown, # # update_cursor # Window_ScanElements: initialize, window_width, refresh, # # disc_element_type, draw_all_weak, # # draw_all_resist, xicon, col2, # # weaknesses, resistances, # # all_element_type, draw_all_elements, # # draw_all_states, line_offset, text_pos, # # font_size, row_height, state_color, # # enemy, update_cursor # # Window_ScanBio: initialize, refresh, bio, enemy, # # contents_height, update_cursor # # RPG::Enemy: bio, hidden_stats, set_bio_info, # # set_hidden_stats # # RPG::UsableItem: scan_types, libra?, set_scan_type # ###--------------------------------------------------------------------------### ###--------------------------------------------------------------------------### # Instructions: # # Place this script in the "Materials" section of the scripts above main. # # This script adds a scan scene to battles that allows the player to view # # info on enemies by pressing a designated key. There are multiple tags # # that may be used in enemies, skills, and items to allow different types of # # scan functions to be used. # ###----- -----### # Enemy Tags: # # -and- # # Sets the text between these tags to the bio description for the enemy. # # This automatically formats allowing you to type the entire bio in a # # single line in the notebox and then showing it over the required lines # # on the scan screen. # # USAGE: # # # # Enemy bio goes here. You can type it all on one line. # # Or you can use more than one line. # # # # hide hp -and/or- hide mp -and/or- hide tp # # Hides the designated stat in the info box. You can use one or each tag # # to hide several options at once. # ###----- -----### # Skill/Item Tags: # # scan[libra] # # The skill gains a libra effect opening a scan window on the enemy the # # skill is used on. # # scan[all] # # When the skill use used on a foe, it reveals all info about an enemy. # # This does not count hidden stats such as HP and MP. Also, this tag will # # have no effect unless DISCOVER_TYPE is set to true. # # scan[weak elements] -or- scan[strong states] -or- scan[weak] -etc- # # Scans only specific parts of the attributes sections. You can use the # # words "strong" or "weak" and/or "elements" or "states" to reveal # # whichever attributes you want revealed. Note that if you use two words, # # strong/weak must come before elements/states. Several similar tags can # # be present in a single skill or item. # ###--------------------------------------------------------------------------### ###--------------------------------------------------------------------------### # These are the default values used by several of the functions in the # # script. You may change these values as you find your game requires in # # order to give the player a better playing experience based on your game. # # # module CP # Do not touch # module SCAN # these two lines. # ###----- -----### # These are the high and low values of STATES. A state with an chance higher # # than "TOP" is considered weak. A state with a chance lower than "BOT" is # # considered strong. 1.0 = 100% chance. # STATE_NORM_TOP = 1.0 # Default = 1.0 # STATE_NORM_BOT = 1.0 # Default = 1.0 # # # # Sets the button that can be used to open the scan menu. This can be set to # # nil to disable normal opening of the scan menu. # BUTTON_SCAN = :A # Default = :A # # # # Choose to use the percentage based scan screen (all elements and states # # shown) or the icon based scan screen. # PERCENTAGE_BASED = false # Default = false # # # # Choose if stats and states must be discovered or if they are all shown by # # default. # DISCOVER_TYPE = true # Default = true # # # # This is the text that displays on undiscovered affinities in the percentage # # based screen. # HIDDEN_STAT = "--%" # Default = "--%" # # # # Determine if an info window is used to tell the player what button to press, # # the text of this window, and the X and Y position of the window. # INFO_WINDOW = true # Default = true # INFO_X = 264 # Default = 304 # INFO_Y = 248 # Default = 248 # INFO_TEXT = "Press shift for enemy info" # # # # This is the text that displays in the discovery type scan screen that above # # the icons. # WEAK_TEXT = "Weaknesses" # Default = "Weaknesses" # RESIST_TEXT = "Resistances" # Default = "Resistances" # # # # This is the text that displays when HP, MP, or TP is hidden. # HIDDEN_TEXT = "? ? ?" # Default = "? ? ?" # # # # This hash contains all the elements that can be displayed in the scan screen # # and the icon to go with them. You may have as many or as few as you want. # # The ID relates to the element's ID in the "Terms" page of the database. # ELEMENTS ={ # # ID => Icon, # 1 => 116, 2 => 114, 3 => 96, 4 => 97, 5 => 98, 6 => 99, 7 => 100, 8 => 101, 9 => 102, 10 => 103, } # # # # This hash contains all the states that can be displayed in the scan screen # # and the icon to go with them. If you want to use the same icon from the # # database, set the icon number to nil. # STATES ={ # # ID => Icon, # 1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8, } # # # # These are the different things to be shown in each row of the namebox. You # # can set up as many or as few as you want in each one. You may also remove # # any lines of this hash as you want. The valid tags for terms are :name, # # :states, :hp, :mp, and :tp. If you want a blank to be included, use an # # empty array for that line. Also note that the height of the name and # # element windows are dependant on the number of rows you set here with a max # # of 4 rows and a minimum of 2 rows. # NAMEBOX ={ # 0 => [:name, :states], 1 => [:hp], 2 => [:mp, :tp], #3 => [], } # # # ###----- -----### # The following options can only be used if CP Pop-ups version 1.2 or higher # # is also present in the game. # # # # The text to display for skills that a battler is strong or weak to. # WEAK_POP = "Weakness" # Default = "Weakness" # STRONG_POP = "Resist" # Default = "Resist" # # # ###--------------------------------------------------------------------------### ###--------------------------------------------------------------------------### # The following lines are the actual core code of the script. While you are # # certainly invited to look, modifying it may result in undesirable results. # # Modify at your own risk! # ###--------------------------------------------------------------------------### end end $imported = {} if $imported.nil? $imported["CP_SCAN_SCENE"] = 1.2 class Game_System alias cp_scan_init initialize def initialize ## Adds the new hashes to store known affinities. cp_scan_init @known_elements = {} @known_states = {} end def scan_known_elements(mob) mob = mob.enemy.id ## Checks known elements/states based on arguments. @known_elements = {} if @known_elements.nil? @known_elements[mob] = [] unless @known_elements.include?(mob) return @known_elements[mob] end def scan_known_states(mob) mob = mob.enemy.id @known_states = {} if @known_states.nil? @known_states[mob] = [] unless @known_states.include?(mob) return @known_states[mob] end def add_known_element(mob, element) mob = mob.id ## Adds a new id to the affinity array. return unless CP::SCAN::ELEMENTS.include?(element) @known_elements = {} if @known_elements.nil? @known_elements[mob] = [] unless @known_elements.include?(mob) return if @known_elements[mob].include?(element) @known_elements[mob].push(element) end def add_known_state(mob, state) mob = mob.id return unless CP::SCAN::STATES.include?(state) @known_states = {} if @known_states.nil? @known_states[mob] = [] unless @known_states.include?(mob) return if @known_states[mob].include?(state) @known_states[mob].push(state) end end class Game_Battler alias cp_scan_item_apply item_apply def item_apply(user, item) cp_scan_item_apply(user, item) cp_scan_enemy(item) unless item.scan_types.empty? return if !@result.hit? ## Adds an element to the affinity array. if item.damage.element_id < 0 return if user.atk_elements.empty? max_id_val = elements_max_rate(user.atk_elements) do_weak_res_pop(max_id_val) return if actor? user.atk_elements.each do |id| next unless element_rate(id) == max_id_val $game_system.add_known_element(enemy, id) end else rate = element_rate(item.damage.element_id) do_weak_res_pop(rate) return if actor? $game_system.add_known_element(enemy, item.damage.element_id) end end def do_weak_res_pop(rate) return unless $imported["CP_BATTLEVIEW"] && $imported["CP_BATTLEVIEW"] >= 1.2 do_weak_pop if rate > 1.0 do_strong_pop if rate < 1.0 end def do_weak_pop pop = CP::BATTLEVIEW::POP_STYLE[:weak_pop] create_pop(CP::SCAN::WEAK_POP, :weak_pop, pop) end def do_strong_pop pop = CP::BATTLEVIEW::POP_STYLE[:strong_pop] create_pop(CP::SCAN::STRONG_POP, :strong_pop, pop) end alias cp_scan_state_attack item_effect_add_state_attack def item_effect_add_state_attack(user, item, effect) cp_scan_state_attack(user, item, effect) user.atk_states.each do |id| scan_check_rate(id) end end ## Check the states used by the skill and adds them to the array. alias cp_scan_state_normal item_effect_add_state_normal def item_effect_add_state_normal(user, item, effect) cp_scan_state_normal(user, item, effect) scan_check_rate(effect.data_id) end def scan_check_rate(id) ## Common function that determines array args. return if actor? $game_system.add_known_state(enemy, id) end def cp_scan_enemy(item) ## Gets the basic types of scans on a skill. return if actor? item.scan_types.each do |type| case type when :we scan_weak_elements when :se scan_strong_elements when :ws scan_weak_states when :ss scan_strong_states when :e scan_element_affinities when :s scan_state_affinities end end end def scan_element_affinities CP::SCAN::ELEMENTS.each do |id, icon| $game_system.add_known_element(enemy, id) end end def scan_state_affinities CP::SCAN::STATES.each do |id, icon| $game_system.add_known_state(enemy, id) end end def scan_weak_elements ## Performs the designated scan. CP::SCAN::ELEMENTS.each do |id, icon| rate = element_rate(id) next if rate <= 1.0 $game_system.add_known_element(enemy, id) end end def scan_weak_states CP::SCAN::STATES.each do |id, icon| rate = state_rate(id) next if rate <= CP::SCAN::STATE_NORM_TOP $game_system.add_known_state(enemy, id) end end def scan_strong_elements CP::SCAN::ELEMENTS.each do |id, icon| rate = element_rate(id) next if rate >= 1.0 $game_system.add_known_element(enemy, id) end end def scan_strong_states CP::SCAN::STATES.each do |id, icon| rate = state_rate(id) next if rate >= CP::SCAN::STATE_NORM_BOT $game_system.add_known_state(enemy, id) end end end class Scene_Battle < Scene_Base alias cp_scan_create_all_windows create_all_windows def create_all_windows ## Adds the new scan window stuff. cp_scan_create_all_windows create_scan_windows end alias cp_create_enemy_window create_enemy_window def create_enemy_window ## Adds a new enemy window method. cp_create_enemy_window @enemy_window.set_handler(:scan, method(:open_enemy_scan)) end def create_scan_windows ## Creates all required graphics for scanning. @scan_viewport = Viewport.new(0, 0, Graphics.width, Graphics.height) @scan_viewport.z = 400 @scan_viewport.visible = false @scan_enemy = Window_ScanEnemy.new @scan_bio = Window_ScanBio.new @scan_elements = Window_ScanElements.new @scan_info = Window_ScanInfo.new @scan_info.z = 400 @scan_info.visible = false scan_windows.each do |wind| wind.viewport = @scan_viewport end @scan_enemy.set_handler(:ok, method(:close_enemy_scan)) @scan_enemy.set_handler(:cancel, method(:close_enemy_scan)) @scan_enemy.set_handler(:pagedown, method(:next_enemy)) @scan_enemy.set_handler(:pageup, method(:last_enemy)) end def open_enemy_scan @from_selection = true open_scan_window @scan_enemy.lock_foe = false @enemy_window.deactivate @scan_enemy.activate end ## Open and close the enemy scan. def close_enemy_scan close_scan_window close_from_selection if @from_selection @from_selection = false end def next_enemy scan_windows.each do |wind| wind.index += 1 next unless wind.index == $game_troop.alive_members.size wind.index = 0 end scan_windows.each {|wind| wind.refresh} @scan_enemy.activate end ## Next and last enemies.... def last_enemy scan_windows.each do |wind| wind.index -= 1 next unless wind.index == -1 wind.index = $game_troop.alive_members.size - 1 end scan_windows.each {|wind| wind.refresh} @scan_enemy.activate end def scan_windows ## Quickly returns each scan window. return [@scan_enemy, @scan_bio, @scan_elements] end alias cp_scan_next_command next_command def next_command @scan_info.visible = false cp_scan_next_command end alias cp_scan_update update def update cp_scan_update return unless @scan_info && @enemy_window @scan_info.visible = @enemy_window.active end def open_scan_window(target = nil) @window_tot_vis = {} instance_variables.each do |varname| ivar = instance_variable_get(varname) next unless ivar.is_a?(Window) next if ivar.viewport == @scan_viewport @window_tot_vis[varname] = ivar.visible ivar.visible = false end if target target = $game_troop.alive_members.index(target) end enemy = target || @enemy_window.index scan_windows.each {|wind| wind.index = enemy; wind.refresh} @scan_viewport.visible = true @scan_enemy.lock_foe = true @scan_enemy.activate end def close_scan_window instance_variables.each do |varname| ivar = instance_variable_get(varname) next unless ivar.is_a?(Window) next if ivar.viewport == @scan_viewport ivar.visible = @window_tot_vis[varname] end scan_windows.each do |wind| wind.index = @enemy_window.index end @scan_viewport.visible = false end def close_from_selection @enemy_window.activate @scan_enemy.deactivate end alias cp_scan_action invoke_item def invoke_item(target, item) scan_windows.each {|w| w.index = $game_troop.alive_members.index(target)} target.cp_scan_enemy(item) if item.libra? open_scan_window(target) if item.libra? update_for_wait while @scan_viewport.visible cp_scan_action(target, item) end end ##----- ## The new windows are located below. ##----- class Window_ScanEnemy < Window_Selectable attr_accessor :lock_foe def initialize w = !CP::SCAN::PERCENTAGE_BASED ? 208 : 200 h = fitting_height([[CP::SCAN::NAMEBOX.size, 2].max, 4].min) super(0, 0, w, h) @index = 0 @lock_foe refresh end def refresh contents.clear CP::SCAN::NAMEBOX.each do |id, array| next unless [0, 1, 2, 3].include?(id) next if (array.nil? || !array.is_a?(Array) || array.empty?) wd = contents.width / array.size array.each_with_index do |key, i| case key when :name draw_text(wd * i + 2, id * line_height, wd, line_height, enemy.name) when :states draw_actor_icons(enemy, wd * i, id * line_height, wd) when :hp draw_enemy_hp(enemy, wd * i + 2, id * line_height, wd - 4) when :mp draw_enemy_mp(enemy, wd * i + 2, id * line_height, wd - 4) when :tp draw_enemy_tp(enemy, wd * i + 2, id * line_height, wd - 4) end end end end def enemy $game_troop.alive_members[@index] end def draw_enemy_hp(battler, x, y, width = 124) unless battler.enemy.hidden_stats.include?(:hp) draw_gauge(x, y, width, battler.hp_rate, hp_gauge_color1, hp_gauge_color2) change_color(system_color) draw_text(x, y, 30, line_height, Vocab::hp_a) change_color(hp_color(battler)) draw_text(x + 32, y, width - 32, line_height, battler.hp.to_i, 2) else change_color(system_color) draw_text(x, y, 30, line_height, Vocab::hp_a) change_color(normal_color) draw_text(x + 32, y, width - 32, line_height, CP::SCAN::HIDDEN_TEXT, 2) end end def draw_enemy_mp(battler, x, y, width = 124) unless battler.enemy.hidden_stats.include?(:mp) draw_gauge(x, y, width, battler.mp_rate, mp_gauge_color1, mp_gauge_color2) change_color(system_color) draw_text(x, y, 30, line_height, Vocab::mp_a) change_color(mp_color(battler)) draw_text(x + 32, y, width - 32, line_height, battler.mp.to_i, 2) else change_color(system_color) draw_text(x, y, 30, line_height, Vocab::mp_a) change_color(normal_color) draw_text(x + 32, y, width - 32, line_height, CP::SCAN::HIDDEN_TEXT, 2) end end def draw_enemy_tp(battler, x, y, width = 124) unless battler.enemy.hidden_stats.include?(:tp) draw_gauge(x, y, width, battler.tp_rate, tp_gauge_color1, tp_gauge_color2) change_color(system_color) draw_text(x, y, 30, line_height, Vocab::tp_a) change_color(tp_color(battler)) draw_text(x + 32, y, width - 32, line_height, battler.tp.to_i, 2) else change_color(system_color) draw_text(x, y, 30, line_height, Vocab::tp_a) change_color(normal_color) draw_text(x + 32, y, width - 32, line_height, CP::SCAN::HIDDEN_TEXT, 2) end end def process_pageup return if @lock_foe super end def process_pagedown return if @lock_foe super end def update_cursor end end class Window_ScanElements < Window_Selectable def initialize w = window_width h = fitting_height([[CP::SCAN::NAMEBOX.size, 2].max, 4].min) super(Graphics.width - w, 0, w, h) @index = 0 refresh end def window_width if !CP::SCAN::PERCENTAGE_BASED return Graphics.width - 208 else icons = [CP::SCAN::ELEMENTS.size, CP::SCAN::STATES.size].max + 24 return [icons * 32, Graphics.width - 200].min end end def refresh contents.clear !CP::SCAN::PERCENTAGE_BASED ? disc_element_type : all_element_type end def disc_element_type draw_all_weak draw_all_resist end def draw_all_weak draw_text(2, 0, 144, line_height, CP::SCAN::WEAK_TEXT, 1) weaknesses.each_with_index do |id, i| draw_icon(id, 24 * (i % xicon), line_height + 24 * (i / xicon)) end end def draw_all_resist draw_text(col2 + 2, 0, 144, line_height, CP::SCAN::RESIST_TEXT, 1) resistances.each_with_index do |id, i| draw_icon(id, col2 + 24 * (i % xicon), line_height + 24 * (i / xicon)) end end def xicon (contents.width / 2) / 24 end def col2 contents.width - xicon * 24 end def weaknesses result = [] CP::SCAN::ELEMENTS.each do |id, icon| next unless enemy.element_rate(id) > 1.0 if CP::SCAN::DISCOVER_TYPE next unless $game_system.scan_known_elements(enemy).include?(id) end result.push(icon) end CP::SCAN::STATES.each do |id, icon| next unless enemy.state_rate(id) > CP::SCAN::STATE_NORM_TOP next if enemy.state_resist?(id) if CP::SCAN::DISCOVER_TYPE next unless $game_system.scan_known_states(enemy).include?(id) end result.push(icon ? icon : $data_states[id].icon_index) end return result end def resistances result = [] CP::SCAN::ELEMENTS.each do |id, icon| next unless enemy.element_rate(id) < 1.0 if CP::SCAN::DISCOVER_TYPE next unless $game_system.scan_known_elements(enemy).include?(id) end result.push(icon) end CP::SCAN::STATES.each do |id, icon| next unless (enemy.state_rate(id) < CP::SCAN::STATE_NORM_BOT || enemy.state_resist?(id)) if CP::SCAN::DISCOVER_TYPE next unless $game_system.scan_known_states(enemy).include?(id) end result.push(icon ? icon : $data_states[id].icon_index) end return result end def all_element_type draw_all_elements draw_all_states end def draw_all_elements i = 0 contents.font.size = font_size CP::SCAN::ELEMENTS.each do |id, icon| known = $game_system.scan_known_elements(enemy).include?(id) if known rate = sprintf("%d%", enemy.element_rate(id) * 100) state_color(enemy.element_rate(id)) else rate = CP::SCAN::HIDDEN_STAT contents.font.color.set(normal_color) end draw_icon(icon, 32 * i + 4, line_offset) draw_text(32 * i, text_pos, 32, font_size, rate, 1) i += 1 end end def draw_all_states i = 0 contents.font.size = font_size CP::SCAN::STATES.each do |id, icon| known = $game_system.scan_known_states(enemy).include?(id) if known perc = enemy.state_resist?(id) ? 0 : enemy.state_rate(id) rate = sprintf("%d%", perc * 100) state_color(perc, true) else rate = CP::SCAN::HIDDEN_STAT contents.font.color.set(normal_color) end iconid = icon ? icon : $data_states[id].icon_index draw_icon(iconid, 32 * i + 4, row_height + line_offset) draw_text(32 * i, row_height + text_pos, 32, font_size, rate, 1) i += 1 end end def line_offset return 0 if CP::SCAN::NAMEBOX.size != 4 return (row_height - line_height) / 2 end def text_pos row_height - font_size end def font_size (line_height * 0.75).to_i end def row_height contents.height / 2 end def state_color(rate, state = false) hrate = state ? CP::SCAN::STATE_NORM_TOP : 1.0 lrate = state ? CP::SCAN::STATE_NORM_BOT : 1.0 if rate > hrate contents.font.color.set(power_up_color) elsif rate < lrate contents.font.color.set(power_down_color) else contents.font.color.set(normal_color) end end def enemy $game_troop.alive_members[@index] end def update_cursor end end class Window_ScanBio < Window_Selectable def initialize w = Graphics.width h = fitting_height(4) super(0, Graphics.height - h, w, h) refresh end def refresh contents.clear draw_text_ex(0, 0, bio) end def bio temp = enemy.bio result = ""; line = "" temp.split(/ /).each do |word| sz = contents.text_size(line).width + contents.text_size("#{word}").width if sz > contents.width - 2 if line.empty? word2 = "" word.chars do |c| s2 = contents.text_size(line).width + contents.text_size("#{c}").width if s2 <= contents.width - 2 line += c else word2 += c end end word = word2 end result += "#{line}\n" line = "#{word} " next else line += "#{word} " end nl = (line =~ /\\n/i) if line.length - 2 == nl result += "#{line}\n" line = word end end result += "#{line}" return result end def enemy $game_troop.alive_members[@index].enemy end def contents_height height - standard_padding * 2 end def update_cursor end end class Window_BattleEnemy < Window_Selectable alias cp_scan_update update def update cp_scan_update return unless active call_handler(:scan) if Input.trigger?(CP::SCAN::BUTTON_SCAN) end end class RPG::Enemy < RPG::BaseItem def bio set_bio_info if @bio.nil? return @bio end def hidden_stats set_hidden_stats if @hidden_stats.nil? return @hidden_stats end def set_bio_info @bio = "" get_bio = false self.note.split(/[\r\n]+/).each do |line| case line when //i get_bio = true next when /<\/bio>/i return end next unless get_bio @bio += "#{line}\n" end end def set_hidden_stats @hidden_stats = [] self.note.split(/[\r\n]+/).each do |line| case line when /hide hp/i @hidden_stats.push(:hp) when /hide mp/i @hidden_stats.push(:mp) when /hide tp/i @hidden_stats.push(:tp) end end @hidden_stats.uniq! end end class RPG::UsableItem < RPG::BaseItem def scan_types set_scan_type if @scan_types.nil? return @scan_types end def libra? set_scan_type if @libra_skill.nil? return @libra_skill end def set_scan_type @scan_types = [] @libra_skill = false self.note.split(/[\r\n]+/).each do |line| case line when /scan\[libra\]/i @libra_skill = true when /scan\[all\]/i @scan_types = [:e, :s] when /scan\[(strong|weak)?\s*(elements|states)?\]/i affinity = $1.to_s.downcase; type = $2.to_s.downcase if affinity == "" @scan_types += [:e] if type == "elements" @scan_types += [:s] if type == "states" elsif type == "" @scan_types += [:se, :ss] if affinity == "strong" @scan_types += [:we, :ws] if affinity == "weak" elsif affinity == "strong" if type == "elements" @scan_types.push(:se) elsif type == "states" @scan_types.push(:ss) end elsif affinity == "weak" if type == "elements" @scan_types.push(:we) elsif type == "states" @scan_types.push(:ws) end end end end @scan_types.uniq! end end class Window_ScanInfo < Window_Base def initialize super(CP::SCAN::INFO_X, CP::SCAN::INFO_Y, 280, fitting_height(1)) self.back_opacity = 255 refresh end def refresh contents.clear draw_text(2, 0, contents.width - 4, line_height, CP::SCAN::INFO_TEXT, 1) self.opacity = 0 if !CP::SCAN::INFO_WINDOW self.contents_opacity = 0 if !CP::SCAN::INFO_WINDOW end end ###--------------------------------------------------------------------------### # End of script. # ###--------------------------------------------------------------------------###