Taiki. 0 Posted October 19, 2018 (edited) Hi everyone, I use this very useful script in my project who is made by Ceodore but modified by GreatRedSpirit. You can find this script here: https://rpgmaker.net/forums/topics/15877/ This is the script: Spoiler =begin ================================================================================ CDR - Guide 1.0 ------------------------------------------------------------------------------- Author: Ceodore Mail: ceodore@email.com https://ceodoremaker.wordpress.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'] = true module 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 = "Guide List" # The string for unread guides on guide list NEW_STRING = "NEW" # The string for the help window on the guide list scene HELP_WINDOW_TEXT = "Select a Guide" # 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,2], # 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}] [1, {:hp => 100, :tp => 20, :mp => 20}], [2, {: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_Base, # 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 => "How to Use the Status Screen", # 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, "This is the Status screen. Here you can see the hero details. You can switch between heroes using \\c[4]Q\\c[0] and \\c[4]W\\c[0] keys on your keyboard. ", {:background => 1, :position => 1}], [:show_picture, 1, "Animal-Statue", 0, -478, 0, 100, 100, 255, 0], [:move_picture, 1, 0, 544, 0, 100, 100, 255, 0, 60], [:key, :R, 3], [:msg, "Now you know how to use the Status screen!", {:background => 1, :position => 1}], [:erase_picture, 1], ]}, #end of example guide # Example of battle guide 2 => { :scene => Scene_Battle, :troop => 1, # 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 data end #============================================================================== # 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 end end #============================================================================== # ** 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 end end #============================================================================== # ** 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? end end #============================================================================== # ** Game_Party #============================================================================== class Game_Party < Game_Unit #-------------------------------------------------------------------------- # * new method: identifies as a mock party #-------------------------------------------------------------------------- def mock_party? false end end #============================================================================== # ** 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 end end #============================================================================== # ** 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 create_pictures 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? update_pictures 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 :show_picture show_picture(command) GuideManager.next_command when :move_picture move_picture(command) GuideManager.next_command when :erase_picture erase_picture(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 def show_picture(command) id = command[1] picture_name = command[2] origin = command[3] x = command[4] y = command[5] zoom_x = command[6] zoom_y = command[7] opacity = command[8] blend_type = command[9] get_picture(id).show(picture_name, origin, x, y, zoom_x, zoom_y, opacity, blend_type) end def move_picture(command) id = command[1] origin = command[2] x = command[3] y = command[4] zoom_x = command[5] zoom_y = command[6] opacity = command[7] blend_type = command[8] duration = command[9] get_picture(id).move(origin, x, y, zoom_x, zoom_y, opacity, blend_type, duration) end def erase_picture(command) id = command[1] get_picture(id).erase end # For pictures to appear anywhere we need to c/p the picture implementation of Spriteset_Map's pictures def create_pictures @pictures = [] @picture_sprites = [] @picture_viewport = Viewport.new @picture_viewport.z = @message_window.z - 1 end def get_picture(id) @pictures[id] = Game_Picture.new(id) if @pictures[id].nil? return @pictures[id] end def dispose_pictures if not @pictures.nil? @pictures.compact.each { |pic| pic.erase } @pictures = nil end @picture_sprites.compact.each {|sprite| sprite.dispose } unless @picture_sprites.nil? end def update_pictures return if @pictures.nil? @pictures.compact.each do |pic| pic.update @picture_sprites[pic.number] ||= Sprite_Picture.new(@picture_viewport, pic) @picture_sprites[pic.number].update end 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 dispose_pictures end end class 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 end end class 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 end end #============================================================================== # ** 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 end end #============================================================================== # ** 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 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] end end #============================================================================== # ** 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) end end #============================================================================== # ** 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? end end However, i encountered some problems like: - When i save the game, the tutorials doesn't save. So when i restart, i lost them. - It should fix the battleback for the tutorial battle like the bgm who is already preset. ex: BATTLE_GUIDE_BGM = ["Battle2"] - Sometimes my game doesn't start the battle tuto. Thanks for your help. Edited October 21, 2018 by Taiki. Share this post Link to post Share on other sites
Taiki. 0 Posted October 23, 2018 If anyone can at least fix the problem with the tutorials who doesn't save. Thank you in advance, it would help me a lot for my project. Share this post Link to post Share on other sites
