Confira o Videos Épicos #45!
8 Respostas 471 Visualizações
0 Membros e 1 Visitante estão vendo este tópico.
# ** Window_GuideList#==============================================================================class Window_GuideList < Window_Selectable def initialize(x, y, width, height) super(x, y, width, height) make_item_list refresh @index = 0 self.activate self.z = 9999 end
=begin================================================================================ CDR - Guide 1.0 ------------------------------------------------------------------------------- Author: Ceodore Mail: ceodore@email.com http://www.condadobraveheart.com ===============================Change log======================================= 16/03/2013 - 1.0 release. ===============================Description====================================== This implementation is meant to provide a way to guide the user on a scene. It was made to allow in-game tutorials, like menu or battle tutorials. =================================License======================================== You may freely use and modify this script as long as you do not change the original author information. If you use this on your game, include the author on the credits.=========================Instalation & Compatibility============================ Insert this script above main. Currently, only menu scenes, shop scenes and battle scenes were tested.===================================Use========================================== You just need to follow the examples and create your sequences. To enable a guide on the list, call a script event command and paste this line: GuideManager.enable(x) Where x is the guide id/switch. Alternatively, you can enable the guide by turning it's Switch ON. In this case, the guide will start automatically once when you enter the scene, but this feature is still experimental, you may use it at your own risk. You can use wathever tags you would use on a message, just don't forget to escape code characters, for example, \C[1] must be put as \\C[1]. This happens because the strings on this script are not treated as your regular message strings, where the \ character is automatically escaped.=================================Commands======================================= The guide will follow a list of commands, wich can be a key input or a message, this is the list of currently supported commands: ## Show Message ## [:msg, "string", {:face_name => string, :face_index => int, :background => int, :position => int}] This will display the string on a message window. The values on the dictionary are all optional, If you are not using any options, you can just use this format: [:msg, string] :face_name stands for the face file name placed on the Graphics/Faces dir :face_index stands for the face index inside the image, if you define a face name, you MUST define a face index. The :background and :position have specific values, explained below: :background 0 -> Normal Window 1 -> Dim Background 2 -> Transparent :position 0 -> Top of the screen 1 -> Middle of the screen 2 -> Bottom of the screen ## Show Message (Battle) ## [:msg, {:wait => int}] For the sake of compatibility with various battle scripts, the guide messages are displayed in the battle log on battle scenes, instead of a normal message window. You can use pretty much all message codes, like display icons, change colors, an all... but there are obvious limitations: 1. The battle log works with a line at a time. You can pile then in sequence, but it will hardly look like a default message window. 2. The battle log will not accept default message window options, like face, position or background. The big advantage is that the battle log window can be displayed at any moment without closing any window, so the guide flux will not be stopped to show a message. The :wait option stands for the time before the message closes automatically. It's optional, default is 10. ## Change Switch ## [:sw, number, boolean] Specifies a switch to be turned on or off. ## Change Variable ## [:var, number, string] The string can contain a number or any expression wich could be processed by the eval() method, like "1 * 2" or "$game_variables[2]", the generated value will be assigned to the specified variable. ## Input Key ## [:key, input, times] This will force a key input. It supports any inputable character the RPG Maker accepts. Here are the main ones for menus: :DOWN -> Forces down key :UP -> Forces up key :RIGHT -> Forces right key :LEFT -> Forces left key :R -> Forces page down key :L -> Forces page up key :C -> Forces confirm key :B -> Forces cancel key The times parameter is optional and stands for the number of times this command will repeat. When no times attribute is found, it will execute the command once. ## Change Rate ## [:rate, number] Changes the update rate to this number, the update rate will be restored to default value at the guide's end.=================================================================================end$imported = {} if $imported.nil?$imported['CDR-Rows'] = truemodule CDR_GUIDE # This defines the interval between commands, in frames. Smaller the value, # higher the speed DEFAULT_UPDATE_RATE = 40 # This defines if the Guide List menu item will be added. This new item # will be placed below End Game and can access the guide list scene. ADD_MENU_ITEM = true # This defines the index of the icon wich will be displayed as the file # icon for each available guide on the Guide_Scene. GUIDE_FILE_ICON = 286 # The menu item name MENU_ITEM_NAME = "Ajuda" # The string for unread guides on guide list NEW_STRING = "Novo" # The string for the help window on the guide list scene HELP_WINDOW_TEXT = "Selecione um Tutoprial" # The color for unread guides on guide list NEW_COLOR = 6 # The bgm to be played when you are on a guide. Set as nil if you do not wish # a specific BGM. # [file name, {options}] GUIDE_BGM = ["Field2",{:volume=>100, :pitch=>100, :pos=>0}] # The bgm to be played when you are on a shop guide. Set as nil if you do not # wish a specific BGM. # [file name, {options}] SHOP_GUIDE_BGM = ["Field2"] # The bgm to be played when you are on a battle guide. Set as nil if you # do not wish a specific BGM. # [file name, {options}] BATTLE_GUIDE_BGM = ["Battle2"] #============================================================================= # MOCK_PARTY_DATA #============================================================================= # Here is the list of fake parties for guide purposes. It can be realy useful # if your guide depends on the selection of a specific party member, or a # specific party state, like certain item available on top of the item list, # a member with depleted HP or high TP. After the guide stops, the original # party will be automatically restored as it was. The dictionary key is for # reference only, but must be unique for each mock party. MOCK_PARTY_DATA = { 1 => { # Optional, the party member's ids :members => [1,], :materia => [[1,1]], # Optional, the weapons on the party inventory :weapon => [# [id, quantity] [1,1] ], # Optional, the armor's id's on the party inventory :armor => [# [id, quantity] [1,1], [2,1] ], # Optional, the item's id's on the party inventory :item => [# [id, quantity] [1,2] ], # Optional, the party gold amount :gold => 1000, # Actor setup, here you can define default values for each actor :setup => [ # [actor_id, {options}] [11, {:hp => 100, :tp => 20, :mp => 20}], [12, {:hp => 150}], ] }, #end of example mock party }#end of mock party data #============================================================================= # GUIDE_DATA #============================================================================= # This is the dictionary of guides, please follow the example to create one, # please read the comments carefully. # The ID of the guide (the key for the dictionary item) references for a # game SWITCH, so the guide will be ready to start every time the switch is # turned on and you are on the guide's scene. GUIDE_DATA = { # Example of menu guide. This will guide the player to the status scene. 1 => {# The guide type can be either :menu or :battle, a menu guide will # aways start from the main menu. :scene => Scene_Menu, # The mock party id, this is optional, when no :party attribute is # defined, the current party will be used. :party => 1, # The guide name to be displayed on the guide list. :name => "Como Usar o Sistema de Materia (Basico)", # An array containing this guide's commands :commands => [ # Notice how the message is placed on this example. When you # break a line on the editor, the line break will be considered # on the message, however, the spaces from the left corner too, # so unless you intent to leave spaces on the line's left, lean # the line on the left corner. Another thing to notice are the # escaped characters, let's say you would put a message # code \C[1], instead you MUST put the extra \ before it, so it # becomes \\C[1]. If you don't, it will display an error. [:msg, "Agora você ira aprende o funcionamento do sistemade materias. primeiramente vá na aba Materias. ", {:background => 1, :position => 1}], [:rate, 8], [:key, :DOWN, 5], [:key, :C, 2 ], [:msg, "Esse sistema e muito facil e simples de ser usado.Repare que os itens possuem alguns slots.", {:background => 1, :position => 1}], [:key, :RIGHT, 1], [:key, :LEFT, 1], [:key, :RIGHT, 1], [:key, :LEFT, 1], [:rate, 10], [:msg, " agora selecione 1 materia e equipe no slot.", {:background => 1, :position => 1}], [:key, :C, 2], [:rate, 10], [:key, :ESC, 2], [:rate, 1], ]}, #end of example guide # Example of battle guide 2 => { :scene => Scene_Battle, :troop => 31, # Required, a battle must have a troop id. :party => 1, :name => "How to Attack the Enemy", :commands => [ [:key, :C], [:msg, "When the actor menu appears, select Attack." ], [:key, :C], [:msg, "Now, select an enemy." ], [:key, :C,3], [:msg, "Now you know how to attack!" ] ] }, # Example of shop guide 3 => { :scene => Scene_Shop, :name => "How to Buy an Item", :party => 1, :goods => { # Optional, this will define the goods the shop will sell :weapon => [1,2,3], :armor => [1,2,3], :item => [1,2,3] }, :commands => [ [:msg, "Select the Buy option."], [:key, :C], [:msg, "Now you select an item."], [:key, :C], [:msg, "Select the quantity."], [:key, :RIGHT, 2], [:msg, "Now, confirm the buy."], [:key, :C], [:msg, "Now you know how to buy!"], ] }, }#end of guide dataend#==============================================================================# DO NOT CHANGE beyond this point, unless you know what you're doing.#==============================================================================# Input module duplicate to use the original methods.SuperInput = Input.dup#==============================================================================# ** Input#==============================================================================module Input # Flag that defines the currently forced key. @force_key = :NONE # Flag that defines if player input is halted. @halt_player_input = false # Flag that indicates if the key to be forced was used @pending_key = false #-------------------------------------------------------------------------- # * method rewrite: adds key forcing logics #-------------------------------------------------------------------------- def self.repeat?(input) return true if @force_key == input return false if @force_key != :NONE return SuperInput.repeat?(input) if !@halt_player_input return false end #-------------------------------------------------------------------------- # * method rewrite: adds key forcing logics #-------------------------------------------------------------------------- def self.trigger?(input) if @force_key == input @force_key = :NONE return true end return SuperInput.trigger?(input) if !@halt_player_input return false end #-------------------------------------------------------------------------- # * method rewrite: adds key forcing logics #-------------------------------------------------------------------------- def self.press?(input) return true if @force_key == input return false if @force_key != :NONE return SuperInput.press?(input) if !@halt_player_input return false end #-------------------------------------------------------------------------- # * new method: defines the key to be forced #-------------------------------------------------------------------------- def self.force_key(input) @force_key = input end #-------------------------------------------------------------------------- # * new method: returns true if a key is being forced #-------------------------------------------------------------------------- def self.force_key? return @force_key != :NONE end #-------------------------------------------------------------------------- # * new method: halts player input #-------------------------------------------------------------------------- def self.halt @halt_player_input = true end #-------------------------------------------------------------------------- # * new method: releases player input #-------------------------------------------------------------------------- def self.release @halt_player_input = false endend#==============================================================================# ** Sound#==============================================================================module Sound #-------------------------------------------------------------------------- # * new method: plays the guide default bgm #-------------------------------------------------------------------------- def self.play_guide_bgm play_bgm(CDR_GUIDE::GUIDE_BGM) if CDR_GUIDE::GUIDE_BGM end #-------------------------------------------------------------------------- # * new method: plays the battle guide default bgm #-------------------------------------------------------------------------- def self.play_battle_guide_bgm play_bgm(CDR_GUIDE::BATTLE_GUIDE_BGM) if CDR_GUIDE::BATTLE_GUIDE_BGM end #-------------------------------------------------------------------------- # * new method: plays the shop guide default bgm #-------------------------------------------------------------------------- def self.play_shop_guide_bgm play_bgm(CDR_GUIDE::SHOP_GUIDE_BGM) if CDR_GUIDE::SHOP_GUIDE_BGM end #-------------------------------------------------------------------------- # * new method: plays a guide bgm #-------------------------------------------------------------------------- def self.play_bgm(guide_bgm) volume = 100 pitch = 100 pos = 0 if guide_bgm[1] volume = guide_bgm[1][:volume] if guide_bgm[1][:volume] pitch = guide_bgm[1][:pitch] if guide_bgm[1][:pitch] pos = guide_bgm[1][:pos] if guide_bgm[1][:pos] end Audio.bgm_play(sprintf('Audio/BGM/%s', guide_bgm[0]), volume, pitch, pos) Audio.bgs_stop endend#==============================================================================# ** Input#==============================================================================module GuideManager @memory = [] @read = [] @commands = [] @index = 0 @repeat_count = 0 @last_command = false @current_key = 0 @type = nil @update_rate = CDR_GUIDE::DEFAULT_UPDATE_RATE #-------------------------------------------------------------------------- # * new method: defines the guide to be followed #-------------------------------------------------------------------------- def self.guide(key, guide) @current_key = key @memory.push(key) @memory.compact! @memory.uniq! @memory.sort! @commands = guide[:commands] @scene = guide[:scene] return if !guide[:party] mock_party = CDR_GUIDE::MOCK_PARTY_DATA[guide[:party]] $party_backup = $game_party unless $game_party.mock_party? $game_party = Game_MockParty.new if mock_party[:members] mock_party[:members].each{|actor_id| $game_party.add_actor(actor_id)} end if mock_party[:weapon] mock_party[:weapon].each{|item| $game_party.gain_item($data_weapons[item[0]], item[1]) } end if mock_party[:armor] mock_party[:armor].each{|item| $game_party.gain_item($data_armors[item[0]], item[1]) } end if mock_party[:item] mock_party[:item].each{|item| $game_party.gain_item($data_items[item[0]], item[1]) } end if mock_party[:gold] $game_party.gain_gold(mock_party[:gold]) end if mock_party[:setup] mock_party[:setup].each{|change| actor = $game_actors[change[0]] options = change[1] actor.set_hp(options[:hp]) if options[:hp] actor.set_tp(options[:tp]) if options[:tp] actor.set_mp(options[:mp]) if options[:mp] } end end #-------------------------------------------------------------------------- # * new method: enabled a guide in the Guide_Scene #-------------------------------------------------------------------------- def self.enable(key) @memory.push(key) @memory.compact! @memory.uniq! @memory.sort! end #-------------------------------------------------------------------------- # * new method: returns true if guide variable is an empty array #-------------------------------------------------------------------------- def self.disable(key) @memory.remove(key) @memory.sort! end #-------------------------------------------------------------------------- # * new method: enabled a guide in the Guide_Scene #-------------------------------------------------------------------------- def self.mark_as_read return if @current_key == 0 @read.push(@current_key) @read.compact! @read.uniq! @read.sort! end #-------------------------------------------------------------------------- # * new method: returns true if guide variable is an empty array #-------------------------------------------------------------------------- def self.read?(key) @read.include?(key) end #-------------------------------------------------------------------------- # * new method: clears the guide sequence and control variables #-------------------------------------------------------------------------- def self.clear mark_as_read self.replay_bgm_and_bgs @last_command = false @current_key = 0 @commands = [] @index = 0 @repeat_count = 0 @scene = nil @update_rate = CDR_GUIDE::DEFAULT_UPDATE_RATE $game_party = $party_backup if $game_party.mock_party? $game_player.refresh $game_map.need_refresh = true SceneManager.return end #-------------------------------------------------------------------------- # * new method: returns true if guide variable is an empty array #-------------------------------------------------------------------------- def self.empty? @commands.empty? end #-------------------------------------------------------------------------- # * new method: defines a new list of guide commands #-------------------------------------------------------------------------- def self.commands=(commands) @commands = commands end #-------------------------------------------------------------------------- # * new method: defines a new update rate #-------------------------------------------------------------------------- def self.update_rate=(update_rate) @update_rate = update_rate end #-------------------------------------------------------------------------- # * new method: access the current update rate #-------------------------------------------------------------------------- def self.update_rate [@update_rate,1].max end #-------------------------------------------------------------------------- # * new method: returns true if guide variable is an empty array #-------------------------------------------------------------------------- def self.guide_list named = [] @memory.each{|switch| if !CDR_GUIDE::GUIDE_DATA[switch][:name].nil? named.push(switch) end } return named end #-------------------------------------------------------------------------- # * new method: returns true if guide variable is an empty array #-------------------------------------------------------------------------- def self.battle_guide? CDR_GUIDE::GUIDE_DATA[@current_key][:scene] == Scene_Battle end #-------------------------------------------------------------------------- # * new method: defines a new value for guide index #-------------------------------------------------------------------------- def self.index=(index) @index = index end #-------------------------------------------------------------------------- # * new method: defines a new value for repetition counter #-------------------------------------------------------------------------- def self.repeat_count=(count) @repeat_count = count-1 end #-------------------------------------------------------------------------- # * new method: decreases the repetition count #-------------------------------------------------------------------------- def self.decrease_count @repeat_count -= 1 if counting? end #-------------------------------------------------------------------------- # * new method: returns true if the repeat count is bigger than zero #-------------------------------------------------------------------------- def self.counting? @repeat_count > 0 end #-------------------------------------------------------------------------- # * new method: returns the current guide command being processed #-------------------------------------------------------------------------- def self.current_command @last_command = !next_command? @commands[@index] end #-------------------------------------------------------------------------- # * new method: steps to the next command #-------------------------------------------------------------------------- def self.next_command @index += 1 end #-------------------------------------------------------------------------- # * new method: return true if the are any commands left to process #-------------------------------------------------------------------------- def self.next_command? return !@commands[@index+1].nil? end #-------------------------------------------------------------------------- # * new method: returns true if a guide command is running #-------------------------------------------------------------------------- def self.running? return (counting? or next_command?) end #-------------------------------------------------------------------------- # * Save BGM and BGS #-------------------------------------------------------------------------- def self.save_bgm_and_bgs @map_bgm = RPG::BGM.last @map_bgs = RPG::BGS.last end #-------------------------------------------------------------------------- # * Resume BGM and BGS #-------------------------------------------------------------------------- def self.replay_bgm_and_bgs @map_bgm.replay unless @map_bgm.nil? @map_bgs.replay unless @map_bgs.nil? endend#==============================================================================# ** Game_Party#==============================================================================class Game_Party < Game_Unit #-------------------------------------------------------------------------- # * new method: identifies as a mock party #-------------------------------------------------------------------------- def mock_party? false endend#==============================================================================# ** Game_Actor#==============================================================================class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # * new method: changes the actor's hp value #-------------------------------------------------------------------------- def set_hp(hp) self.hp = hp end #-------------------------------------------------------------------------- # * new method: changes the actor's mp value #-------------------------------------------------------------------------- def set_mp(mp) self.mp = mp end #-------------------------------------------------------------------------- # * new method: changes the actor's tp value #-------------------------------------------------------------------------- def set_tp(tp) self.tp = tp end end#==============================================================================# ** Game_MockParty#==============================================================================class Game_MockParty < Game_Party #-------------------------------------------------------------------------- # * new method: identifies as a mock party #-------------------------------------------------------------------------- def mock_party? true endend#==============================================================================# ** Scene_Base#==============================================================================class Scene_Base #-------------------------------------------------------------------------- # * method alias: creates the guide message window #-------------------------------------------------------------------------- alias cdr_guide_start start def start Input.halt $game_message.visible = false if (!self.is_a?(Scene_Map)) create_message_window CDR_GUIDE::GUIDE_DATA.each{ |switch, guide| if($game_switches[switch] and self.is_a?(guide[:scene])) $game_switches[switch] = false GuideManager.guide(switch, guide) break end } end cdr_guide_start Input.release end #-------------------------------------------------------------------------- # * new method: creates the message window #-------------------------------------------------------------------------- def create_message_window @message_window = Window_Message.new @message_window.z = @message_window.z+100 end #-------------------------------------------------------------------------- # * method alias: fires the guide process #-------------------------------------------------------------------------- alias cdr_guide_update update def update update_guide cdr_guide_update end #-------------------------------------------------------------------------- # * new method: process guide logic #-------------------------------------------------------------------------- def wait_for_message @message_window.update update_for_wait while $game_message.visible end #-------------------------------------------------------------------------- # * new method: process guide logic #-------------------------------------------------------------------------- def update_guide return if skip_guide_update? if GuideManager.current_command.nil? GuideManager.clear return end Input.halt return if Graphics.frame_count%GuideManager.update_rate != 0 process_guide_command(GuideManager.current_command) end #-------------------------------------------------------------------------- # * new method: returns true if a guide update must be skipped #-------------------------------------------------------------------------- def skip_guide_update? return true if GuideManager.empty? end #-------------------------------------------------------------------------- # * new method: returns true if a guide update must be skipped #-------------------------------------------------------------------------- def process_guide_command(command) case command[0] when :key Input.force_key(command[1]) if GuideManager.counting? GuideManager.decrease_count else GuideManager.repeat_count = command[2] if !command[2].nil? end GuideManager.next_command if !GuideManager.counting? when :msg process_message(command) GuideManager.next_command when :sw $game_switches[command[1]] = command[2] GuideManager.next_command when :var $game_variables[command[1]] = eval(command[2]) GuideManager.next_command when :rate GuideManager.update_rate = command[1] GuideManager.next_command end end #-------------------------------------------------------------------------- # * new method: process the current message command #-------------------------------------------------------------------------- def process_message(command) $game_message.add(command[1]) if !command[2].nil? options = command[2] $game_message.face_name = options[:face_name] if options[:face_name] $game_message.face_index = options[:face_index] if options[:face_index] $game_message.background = options[:background] if options[:background] $game_message.position = options[:position] if options[:position] end Input.release wait_for_message Input.halt end #-------------------------------------------------------------------------- # * new method: generic method to wait for message proessing #-------------------------------------------------------------------------- def update_for_wait update_basic end #-------------------------------------------------------------------------- # * new method, disposes message window #-------------------------------------------------------------------------- alias cdr_guide_dispose_all_windows dispose_all_windows def dispose_all_windows cdr_guide_dispose_all_windows @message_window.dispose endendclass Scene_Battle < Scene_Base alias cdr_guide_process_message process_message def process_message(command) if GuideManager.battle_guide? wait = 10 wait = command[2][:wait] if command[2] and command[2][:wait] @log_window.add_text(command[1]) wait.times do @log_window.wait end @log_window.back_one else cdr_guide_process_message(command) end end #-------------------------------------------------------------------------- # * new method: returns true if a guide update must be skipped #-------------------------------------------------------------------------- alias cdr_guide_battle_skip_guide_update? skip_guide_update? def skip_guide_update? return true if cdr_guide_battle_skip_guide_update? return false if @item_window.active return false if @skill_window.active return false if @party_command_window.active return false if @actor_command_window.active return false if @status_window.active return false if @enemy_window.active return true endendclass Window_Selectable < Window_Base #-------------------------------------------------------------------------- # * alias: can only process handlers when not locked #-------------------------------------------------------------------------- alias cdr_guide_process_handling process_handling def process_handling wm = self.is_a?(Window_Message) return if (!wm and $game_message.busy? and GuideManager.running?) cdr_guide_process_handling end #-------------------------------------------------------------------------- # * alias: can only process cursor moves when not locked #-------------------------------------------------------------------------- alias cdr_guide_process_cursor_move process_cursor_move def process_cursor_move wm = self.is_a?(Window_Message) return if (!wm and $game_message.busy? and GuideManager.running?) cdr_guide_process_cursor_move endend#==============================================================================# ** Scene_Guide#==============================================================================class Scene_Guide < Scene_Base #-------------------------------------------------------------------------- # * Start Processing #-------------------------------------------------------------------------- def start super create_help_window create_guide_window create_background @guide_window.set_handler(:ok, method(:on_guide_ok)) @guide_window.set_handler(:cancel, method(:return_scene)) end #-------------------------------------------------------------------------- # * Termination Processing #-------------------------------------------------------------------------- def terminate super dispose_background end #-------------------------------------------------------------------------- # * Create Background #-------------------------------------------------------------------------- def create_background @background_sprite = Sprite.new @background_sprite.bitmap = SceneManager.background_bitmap @background_sprite.color.set(16, 16, 16, 128) end #-------------------------------------------------------------------------- # * Free Background #-------------------------------------------------------------------------- def dispose_background @background_sprite.dispose end def update super @guide_window.refresh end #-------------------------------------------------------------------------- # * Aquisição do texto da janela de ajuda #-------------------------------------------------------------------------- def help_window_text return CDR_GUIDE::HELP_WINDOW_TEXT end #-------------------------------------------------------------------------- # * new method: creates each guide window #-------------------------------------------------------------------------- def create_guide_window width = Graphics.width height = Graphics.height - @help_window.height @guide_window = Window_GuideList.new(0, @help_window.height, width, height) @guide_window.viewport = @viewport end #-------------------------------------------------------------------------- # * new method: call selected guide #-------------------------------------------------------------------------- def on_guide_ok $game_switches[@guide_window.item] = true guide = CDR_GUIDE::GUIDE_DATA[@guide_window.item] Sound.play_ok if guide[:scene] == Scene_Battle call_battle_guide(guide[:troop]) elsif guide[:scene] == Scene_Shop call_shop_guide(guide[:goods], guide[:sell]) else GuideManager.save_bgm_and_bgs Sound.play_guide_bgm SceneManager.call(guide[:scene]) end end #-------------------------------------------------------------------------- # * new method: call a battle guide #-------------------------------------------------------------------------- def call_battle_guide(troop_id) if $data_troops[troop_id] GuideManager.save_bgm_and_bgs BattleManager.setup(troop_id, false, true) Sound.play_battle_guide_bgm Sound.play_battle_start SceneManager.call(Scene_Battle) end end #-------------------------------------------------------------------------- # * rewrite: call a shop guide #-------------------------------------------------------------------------- def call_shop_guide(goods_data, sell) goods = [] types = [:item, :weapon, :armor] for type in 0..2 if goods_data[types[type]] goods_data[types[type]].each{|id| goods.push([type, id, 0]) } end end GuideManager.save_bgm_and_bgs Sound.play_shop_guide_bgm SceneManager.call(Scene_Shop) SceneManager.scene.prepare(goods, !sell) end #-------------------------------------------------------------------------- # * Create Help Window #-------------------------------------------------------------------------- def create_help_window @help_window = Window_Help.new(1) @help_window.set_text(help_window_text) @help_window.viewport = @viewport endend#==============================================================================# ** Window_GuideList#==============================================================================class Window_GuideList < Window_Selectable def initialize(x, y, width, height) super(x, y, width, height) make_item_list refresh @index = 0 self.activate self.z = 9999 end #-------------------------------------------------------------------------- # * Create Item List #-------------------------------------------------------------------------- def make_item_list @data = GuideManager.guide_list end #-------------------------------------------------------------------------- # * Draw Item #-------------------------------------------------------------------------- def draw_item(index) rect = item_rect(index) draw_icon(CDR_GUIDE::GUIDE_FILE_ICON, 4, rect.y, enabled = true) change_color(normal_color) draw_guide_name(index, rect.x+28, rect.y) contents.font.bold = true change_color(text_color(CDR_GUIDE::NEW_COLOR)) draw_new_flag(index, rect.x+text_size(guide(index)[:name]).width+24, rect.y) contents.font.bold = false change_color(normal_color) end #-------------------------------------------------------------------------- # * new method: draw_guide_name #-------------------------------------------------------------------------- def draw_guide_name(index, x, y) name = guide(index)[:name] draw_text(x, y, Graphics.width - 120, line_height, name) end #-------------------------------------------------------------------------- # * new method: draw_new_flag #-------------------------------------------------------------------------- def draw_new_flag(index, x, y) return if GuideManager.read?(@data[index]) text = CDR_GUIDE::NEW_STRING draw_text(x, y, 128, line_height, text) end #-------------------------------------------------------------------------- # * method rewrite: returns the max number of guides on the list #-------------------------------------------------------------------------- def item_max GuideManager.guide_list.size end #-------------------------------------------------------------------------- # * new method: returns the guide corresponding to the key #-------------------------------------------------------------------------- def guide(index) CDR_GUIDE::GUIDE_DATA[@data[index]] end #-------------------------------------------------------------------------- # * method rewrite: returns the selected guide key #-------------------------------------------------------------------------- def item @data[@index] endend#==============================================================================# ** Scene_Menu#==============================================================================class Scene_Menu < Scene_MenuBase #-------------------------------------------------------------------------- # * alias: adds a guide list accessor to the main menu #-------------------------------------------------------------------------- alias cdr_guide_create_command_window create_command_window def create_command_window cdr_guide_create_command_window if CDR_GUIDE::ADD_MENU_ITEM @command_window.set_handler(:guide_list, method(:command_guide_list)) end end #-------------------------------------------------------------------------- # * new method: calls the guide list scene #-------------------------------------------------------------------------- def command_guide_list SceneManager.call(Scene_Guide) endend#==============================================================================# ** Window_MenuCommand#==============================================================================class Window_MenuCommand < Window_Command #-------------------------------------------------------------------------- # * alias #-------------------------------------------------------------------------- alias cdr_guide_select_last select_last def select_last if GuideManager.running? select_symbol(nil) return end cdr_guide_select_last end #-------------------------------------------------------------------------- # * alias: to add guide command menu item #-------------------------------------------------------------------------- alias cdr_guide_add_original_commands add_original_commands def add_original_commands cdr_guide_add_original_commands add_guide_list_command if CDR_GUIDE::ADD_MENU_ITEM end #-------------------------------------------------------------------------- # * new method: to add guide command menu item #-------------------------------------------------------------------------- def add_guide_list_command add_command(CDR_GUIDE::MENU_ITEM_NAME, :guide_list, has_guides?) end #-------------------------------------------------------------------------- # * new method: returns true if there is any guides on the list #-------------------------------------------------------------------------- def has_guides? !GuideManager.guide_list.empty? endend
@back_sprite.z = z - 1
@back_sprite.z = 9999
@message_window.z = @message_window.z+100
@message_window.z = @message_window.z + 9999
@materia_bio_window.z = @materia_list_window.z = 1000
@materia_bio_window.z = @materia_list_window.z = 0
Na verdade você não precisa necessariamente mudar o script no Window_Message e nem o script CDR - Guide, isso pode dar problemas futuramente, o que é muito ruim, o que você pode fazer é só mudar o script de Materia System na linha 2119, onde vai estar assim:Código: [Selecionar]@materia_bio_window.z = @materia_list_window.z = 1000Substitua por isso:Código: [Selecionar] @materia_bio_window.z = @materia_list_window.z = 0Isso fará com que a Janela de Materia fique abaixo de qualquer outra janela, mas lembrando que também pode dar problemas futuramente, principalmente se você adicionar mais scripts no Menu, mas pelo menos desse modo envolve apenas 1 script, espero ter lhe ajudado.Abraços do Lyca!
