#============================================================================== # # GaryCXJk - Hacked Together Credits Script v1.02 # * Last Updated: 2014.08.03 # * Level: Easy # * Requires: N/A # #============================================================================== $imported = {} if $imported.nil? $imported["CXJ-HTCredits"] = "1.02" #============================================================================== # # Changelog: # # 2014.08.03 - v1.02 # # * Added: You can now change the opacity using CXJ::HT_CREDITS.opacity # * Added: Custom fonts can now be set # * Added: Unicode now implemented, you can use \u{hex-value} to display the # character # * Added: Icon font support # * Added: A script can now be run when the credits end # * Fixed: Now the credits data is moved to a separate class, allowing for # multiple credits files # * Fixed: White lines are now ignored in the timeline block # #------------------------------------------------------------------------------ # 2012.01.13 - v1.01 # # * Fixed: Made the window update automatically # #------------------------------------------------------------------------------ # 2012.01.03 - v1.00 # # * Initial release # #============================================================================== # # Okay, here's the thing. RPG Maker VX Ace's message system can be very # flexible, to the point where you can use it as a basic credits system. # However, sometimes you want that little bit more flexibility. So, at these # times it would be very nice to see a credits system. # # Now this isn't the best credits script there could be, hence its name. That # doesn't mean it's bad though, it only means it's still very basic, kind of # for people who want to work with a quick script, and that the code is a bit # messy. # #============================================================================== # # Installation: # # Make sure to put this below Materials, but above Main Process. # # This script adds aliases for several methods. If you are sure no method that # is used by other scripts get overridden, you can place it anywhere, # otherwise, make sure this script is loaded after any other script overriding # these methods, otherwise this script stops working. # #------------------------------------------------------------------------------ # Aliased methods: # # * class Scene_Base # - update_basic # #============================================================================== # # Usage: # # There are two ways to use this script. First is changing the current scene # to Scene_Credits. It will automatically return to the last scene after it's # done. This scene is completely bare, save for the credits stuff. Any music # or other effect should be done before this scene. You can also subclass it # to add new functionality. # # The other way is to open a Window_Credits. You can either open one yourself # or use CXJ::HT_CREDITS.refresh to open a global window. To close the window, # use CXJ::HT_CREDITS.terminate_message. Finally, CXJ::HT_CREDITS.credits_end? # checks if the credits reach its end. # # A credits file is a regular text file which contains various data. It # consists of several blocks, defined by square brackets. The [credits] # section is the actual credits text. You can use certain formatting for that. # None of the formatting will transfer over to the next line. # # \IFT[code] - Insert an icon font character. # \C - Change color. The value that follows is four characters wide, # and is a hexadecimal value representing RGBA. # \{ - Enlargen the text by eight. # \} - Shrink the text by eight. # \Ax - Align the text to the center position. # L: Align left. # C: Align center. # R: Align right. # \Px - Sets the center position. # L: At a quarter of the screen. # C: At the center. # R: At three quarters of the screen. # 0-8: A position between the left and right position of the # screen. # \>> - Will process the next line on the same line as the current. # # There is also an easy way to insert unicode characters, by using \u{code}, # where code is the hexadecimal code value of the glyph you want to insert. # Do note that the u has to be lower case. # # The [timeline] section defines events that should happen during the credits # sequence. You can define methods here, either as a symbol or as an evaluated # line. You correctly format the lines as follows: # # time_in_seconds:method string # time_in_seconds::symbol # # Example: # # 5.00:puts('Haldo world!') # 5.10::make_font_bigger # # The [on_credits_end] block is actually a script block, which triggers once # the script terminates, either by reaching the end or by getting terminated # by the player. As the script is run inside the Window_Credits class, you # can use the methods of this class inside this script. # # Finally, [settings] contains the settings. You can assign settings however # you like, if you like. If you decide not to change a setting, you can always # remove them. # # font - The font or fonts (comma separated and in double quotes). # line_height - The font size. # color - The font color, as an eight character hexadecimal value. # duration - The duration of the credits sequence. # scroll_duration - The duration of the scrolling text. # speed - The speed of the scrolling text. # #------------------------------------------------------------------------------ # Icon fonts: # # Icon fonts are generally used for web applications, but I decided to add # compatibility for it in this credits script. Basically an icon font is a # font that only contains icons. This makes the images very scalable. # # To define an icon font, you need to make a hash, which contains the # following blocks: # # :name - The name of the font as it's defined in the font itself # :prefix - The prefix, used to identify the font # :glyph - A list of glyphs # # The glyph block in itself is a hash as well, where the key is the identifier # of the font, and the value is the hexadecimal value associated with the # glyph. # # In the demo I've added an example. I've used FontAwesome as the icon font # to show how it works. I also added a short bit below to show you the # structure of the hash. # # FONTAWESOME = {} # FONTAWESOME[:name] = "FontAwesome" # FONTAWESOME[:prefix] = "fa-" # FONTAWESOME[:glyph] = {} # FONTAWESOME[:glyph]["adjust"] = "f042" # FONTAWESOME[:glyph]["adn"] = "f170" # #============================================================================== # # License: # # CC0 1.0 Universal (CC0 1.0) # Public Domain Dedication # # The complete license can be read here: # https://creativecommons.org/publicdomain/zero/1.0/legalcode # # The license as it is described below can be read here: # https://creativecommons.org/publicdomain/zero/1.0/deed # # No Copyright # # The person who associated a work with this deed has dedicated the work to the # public domain by waiving all of his or her rights to the work worldwide under # copyright law, including all related and neighboring rights, to the extent # allowed by law. # # You can copy, modify, distribute and perform the work, even for commercial # purposes, all without asking permission. See Other Information below. # # Other Information # # * In no way are the patent or trademark rights of any person affected by CC0, # nor are the rights that other persons may have in the work or in how the # work is used, such as publicity or privacy rights. # * Unless expressly stated otherwise, the person who associated a work with # this deed makes no warranties about the work, and disclaims liability for # all uses of the work, to the fullest extent permitted by applicable law. # * When using or citing the work, you should not imply endorsement by the # author or the affirmer. # #------------------------------------------------------------------------------ # Clarifications and reasoning: # # This script has been given a CC0 license because I feel it deserves to be # used by everyone without restriction. This ensures that people don't feel # obligated to add a license notice or credits whenever the script is being # used. # # Additional reasoning: # # This script is actually pretty easy to implement yourself, and I feel it's # a bit unfair to ask more from the ones who use it other than that the script # is being used. Besides, asking to be credited on a credits page? That's # pretty redundant. # # I also feel like there are better ways to implement a credits sequence, # especially with the experience I've gained since. # #------------------------------------------------------------------------------ # Extra notes: # # You are free to pick the following names when you give credit: # # * GaryCXJk # * Gary A.M. Kertopermono # * G.A.M. Kertopermono # * GARYCXJK # # I actually don't mind if you don't credit me, but it would always be nice. # # This script was originally hosted on: # http://area91.multiverseworks.com # #============================================================================== # # The code below defines the settings of this script, and are there to be # modified. # #============================================================================== module CXJ module HT_CREDITS # General settings BASE_FONT = ["Verdana", "Arial", "Courier New"] # Base font BASE_HEIGHT = 24 # Base line height TEXT_COLOR = Color.new(255, 255, 255, 255) # Default color DEFAULT_DURATION = 15 # Duration of sequence in secs DEFAULT_SCROLL_DURATION = 0 # Scoll duration in secs DEFAULT_SPEED = 1.0 # Scroll speed ALLOW_MANUAL_CREDITS_CLOSE = true # Manually close Scene_Credits? # Searches through the following files. # It iterates through the file list. If a file can't be found, it moves # on to the next file. Otherwise it loads the data and skips the rest. # When using a packaged file, you can append it with a symbol name. This # way you can store the data in a general package. CREDITS_FILE = [ "Data/Strings.rvdata2:credits", "Data/Credits.rvdata2", "Text/Credits.txt", ] # This list defines the file extensions of packaged files. CREDITS_PACKAGED = [ "rvdata2", ] # Font icons # These are icons embedded in fonts. There isn't much use for it, which # is why I didn't highlight this feature, but in case you do want to use # them, I've included a sample in the demo. ICON_FONTS = [] ICON_FONTS.push(IFT_FontAwesome::FONTAWESOME) if $imported.has_key?("IconFontTable-FontAwesome") #------------------------------------------------------------------------ # Use this module (CXJ::HT_CREDITS::METHODS) or Window_Credits to add new # methods. #------------------------------------------------------------------------ module METHODS def haldo puts("Haldo!") end end end end #============================================================================== # # The code below should not be altered unless you know what you're doing. # #============================================================================== class HT_Credits_Data #------------------------------------------------------------------------ # Initializes the credits. #------------------------------------------------------------------------ def initialize(filename = '') @credits_base_font = CXJ::HT_CREDITS::BASE_FONT @credits_base_height = CXJ::HT_CREDITS::BASE_HEIGHT @credits_base_color = CXJ::HT_CREDITS::TEXT_COLOR @credits_base_duration = CXJ::HT_CREDITS::DEFAULT_DURATION @credits_base_scroll_duration = CXJ::HT_CREDITS::DEFAULT_SCROLL_DURATION @credits_base_speed = CXJ::HT_CREDITS::DEFAULT_SPEED @credits_text = [] @credits_timeline = {} @credits_height = 0 @credits_height_list = [] @credits_on_credits_end_script = "" @credits_base_scroll_duration = CXJ::HT_CREDITS::DEFAULT_DURATION if @credits_base_scroll_duration == 0 if(filename.empty?) CXJ::HT_CREDITS::CREDITS_FILE.each do |filename| process_file(filename) break if !@credits_text.empty? end else process_file(filename) end end #------------------------------------------------------------------------ # Gets credits data as a Hash. #------------------------------------------------------------------------ def get_credits_data data = { :credits => @credits_text, :timeline => @credits_timeline, :on_credits_end => @credits_on_credits_end_script, :settings => { :font => @credits_base_font, :line_height => @credits_base_height, :color => @credits_color, :duration => @credits_base_duration, :scroll_duration => @credits_base_scroll_duratino, :speed => @credits_base_speed, } } end #------------------------------------------------------------------------ # Store credits data as a file. #------------------------------------------------------------------------ def store_credits_data(filename) save_data(get_credits_data, filename) end #------------------------------------------------------------------------ # Process a file. #------------------------------------------------------------------------ def process_file(filename) filedata = filename.split(/:/) filename = filedata[0] return unless File.exists?(filename) extname = File.extname(filename) ext = extname[1, extname.size - 1] if CXJ::HT_CREDITS::CREDITS_PACKAGED.include?(ext) if(filedata.size > 1) process_packaged(filename, filedata[1].to_sym) else process_packaged(filename) end else process_text(filename) end end #------------------------------------------------------------------------ # Process packaged credits data. #------------------------------------------------------------------------ def process_packaged(filename, symbol = nil) credits_data = load_data(filename) return if(credits_data.nil?) if !symbol.nil? return if credits_data[symbol].nil? credits_data = credits_data[symbol] end return if @credits_text.nil? @credits_text = credits_data[:credits] if !credits_data[:credits].nil? @credits_timeline = credits_data[:timeline] if !credits_data[:timeline].nil? @credits_on_credits_end_script = credits_data[:on_credits_end] if !credits_data[:on_credits_end].nil? settings = {} settings = credits_data[:settings] if !credits_data[:settings].nil? @credits_base_font = settings[:font] if !settings[:font].nil? @credits_base_height = settings[:line_height] if !settings[:line_height].nil? @credits_color = settings[:color] if !settings[:color].nil? @credits_base_duration = settings[:duration] if !settings[:duration].nil? @credits_base_scroll_duration = settings[:scroll_duration] if !settings[:scroll_duration].nil? @credits_base_speed = settings[:speed] if !settings[:speed].nil? calculate_total_height end #------------------------------------------------------------------------ # Process a text file. #------------------------------------------------------------------------ def process_text(filename) credits_content = '' File.open(filename, "r") do |file| credits_content = file.read() end tag_open = :none credits_content.split(/[\r\n]/).each do |line| if line =~ /^\s*\[(.*)\]\s*$/i case $1 when "credits" tag_open = :credits when "timeline" tag_open = :timeline when "settings" tag_open = :settings when "on_credits_end" tag_open = :on_credits_end @credits_on_credits_end_script = "" end else case tag_open when :credits line.gsub!(/\\/) { "\e" } line.gsub!(/\e\e/) { "\\" } @credits_text.push(line) when :timeline linepos = line.index(":") unless linepos.nil? linedata = line[0, linepos] posdata = line.split(/\./) curpos = posdata[0].to_i subpos = posdata[1].to_i subpos/= 10.0 while subpos > 1.0 @credits_timeline[curpos + subpos] = line[linepos + 1, line.size - (linepos + 1)] end when :on_credits_end @credits_on_credits_end_script+= line @credits_on_credits_end_script+= "\n" when :settings if line =~ /^\s*(\w+)\s*=\s*(.+)\s*$/ case $1 when "font" @credits_base_font = eval("[" + $2 + "]") when "line_height" @credits_base_height = $2.to_i when "color" @credits_color = process_color($2) when "duration" @credits_base_duration = $2.to_f when "scroll_duration" @credits_base_scroll_duration = $2.to_f when "speed" @credits_base_speed = $2.to_i end end end end end calculate_total_height end #------------------------------------------------------------------------ # Calculate total height. #------------------------------------------------------------------------ def calculate_total_height @credits_height = 0 height_poll = 0 last_i = 0 for i in 0 ... text_count text = text(i) height_poll = [height_poll, get_line_height(text)].max next if text =~ /\e>>/ @credits_height+= height_poll while last_i <= i @credits_height_list[last_i] = height_poll last_i+=1 end height_poll = 0 end @credits_height+= height_poll while last_i < text_count @credits_height_list[last_i] = height_poll last_i+=1 end end #------------------------------------------------------------------------ # Process a color. # Colors are done in hexadecimal format. #------------------------------------------------------------------------ def process_color(color) vals = '0123456789abcdef' value = 0 color = color.downcase while !color.empty? value = (value << 4) | vals.index(color.slice!(0, 1)) end Color.new((value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff) end #------------------------------------------------------------------------ # The base line height. #------------------------------------------------------------------------ def base_font @credits_base_font end #------------------------------------------------------------------------ # The base line height. #------------------------------------------------------------------------ def base_height @credits_base_height end #------------------------------------------------------------------------ # The default color. #------------------------------------------------------------------------ def default_color @credits_base_color end #------------------------------------------------------------------------ # The amount of lines stored. #------------------------------------------------------------------------ def text_count @credits_text.size end #------------------------------------------------------------------------ # The duration of the credits sequence. #------------------------------------------------------------------------ def default_duration @credits_base_duration end #------------------------------------------------------------------------ # The duration of the scrolling text. #------------------------------------------------------------------------ def default_scroll_duration @credits_base_scroll_duration end #------------------------------------------------------------------------ # The default speed for the scrolling text. # Ignored if the duration of the credits sequence is set. #------------------------------------------------------------------------ def default_speed @credits_base_speed end #------------------------------------------------------------------------ # A text line. #------------------------------------------------------------------------ def text(index) @credits_text[index] end #------------------------------------------------------------------------ # The total height of the scrolling text. #------------------------------------------------------------------------ def total_height @credits_height end #------------------------------------------------------------------------ # The height of a given line. #------------------------------------------------------------------------ def get_line_height(text) return @credits_height_list[text] if text.kind_of?(Numeric) result = base_height text.slice(/^.*$/).scan(/\e[\{\}]/).each do |esc| result += 8 if result <= 64 && esc == "\e{" end result end #------------------------------------------------------------------------ # Get the timeline data. #------------------------------------------------------------------------ def get_timeline_data @credits_timeline end #------------------------------------------------------------------------ # Get the script that should execute on credit end. #------------------------------------------------------------------------ def get_on_credits_end return @credits_on_credits_end_script end end module CXJ module HT_CREDITS DEFAULT_CREDITS = HT_Credits_Data.new end end class Window_Credits < Window_Base include CXJ::HT_CREDITS::METHODS #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize(credits_data = nil) super(0, 0, Graphics.width, Graphics.height) self.opacity = 0 self.arrows_visible = false @credits_data = credits_data @credits_data = CXJ::HT_CREDITS::DEFAULT_CREDITS if @credits_data.nil? hide @credits_running = false end #-------------------------------------------------------------------------- # * Set Credits Data #-------------------------------------------------------------------------- def set_credits_data(credits_data) @credits_data = credits_data end #-------------------------------------------------------------------------- # * Get Standard Padding Size #-------------------------------------------------------------------------- def standard_padding return 0 end #-------------------------------------------------------------------------- # * Frame Update #-------------------------------------------------------------------------- def update super update_message if @text start_message if !@text end #-------------------------------------------------------------------------- # * Start Message #-------------------------------------------------------------------------- def start_message @frame_count = 0 @frame_rate = Graphics.frame_rate @frame_end = (@credits_data.default_duration * @frame_rate).floor @frame_end = (@credits_data.default_speed * @credits_data.total_height).ceil unless @frame_end > 0 @text = true calculate_speed refresh show @credits_running = true end #-------------------------------------------------------------------------- # * Calculate Height of Window Contents #-------------------------------------------------------------------------- def contents_height @all_text_height ? @all_text_height : super end #-------------------------------------------------------------------------- # * Update Message #-------------------------------------------------------------------------- def update_message self.oy = @scroll_pos + @speed * @frame_count val = @timeline[@frame_count] if !val.nil? if val.instance_of?(Symbol) method(val).call else eval(val) end end @frame_count+=1 terminate_message if credits_end? end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh reset_font_settings @all_text_height = @credits_data.total_height create_contents draw_all_text set_timeline self.oy = @scroll_pos = -height end #-------------------------------------------------------------------------- # * End Message #-------------------------------------------------------------------------- def terminate_message if @credits_running @credits_running = false eval(@credits_data.get_on_credits_end) end hide end #------------------------------------------------------------------------ # If the credits have ended. #------------------------------------------------------------------------ def credits_end? @frame_count > @frame_end end #------------------------------------------------------------------------ # Draws all text. #------------------------------------------------------------------------ def draw_all_text y = 0 index = 0 while index < @credits_data.text_count create_line(index, y) while index < @credits_data.text_count && @credits_data.text(index) =~ /\e>>/ index+= 1 create_line(index, y) end y+= @credits_data.get_line_height(index) index+= 1 end end #------------------------------------------------------------------------ # Initializes the timeline. #------------------------------------------------------------------------ def set_timeline @timeline = {} @credits_data.get_timeline_data.each do |key,value| dur = (key * @frame_rate).floor val = value val = value[1, value.size - 1].to_sym if(value[0] == ":") @timeline[dur] = val end end #------------------------------------------------------------------------ # Calculate the text speed. #------------------------------------------------------------------------ def calculate_speed def_duration = @credits_data.default_scroll_duration * 1.0 @speed = @credits_data.default_speed @remainder = 0 if def_duration > 0 frame_duration = def_duration * @frame_rate * 1.0 @speed = (@credits_data.total_height + Graphics.height) / frame_duration end end #------------------------------------------------------------------------ # Create a line. #------------------------------------------------------------------------ def create_line(index, yPos) text = @credits_data.text(index).to_s.clone line_height = @credits_data.get_line_height(index) bitmap = Bitmap.new(Graphics.width, Graphics.height) data = {:x => 0, :y => 0, :align => 1, :pos => 0} bitmap.font.name = @credits_data.base_font bitmap.font.size = @credits_data.base_height bitmap.font.color = CXJ::HT_CREDITS::TEXT_COLOR pos = "C" if text =~ /P([LCR])/i pos = $1 end process_char(text.slice!(0, 1), text, bitmap, line_height, data) while !text.empty? case data[:align] when 0 xPos = Graphics.width / 2 + data[:pos] when 1 xPos = (Graphics.width - data[:x]) / 2 + data[:pos] when 2 xPos = Graphics.width / 2 - data[:x] + data[:pos] end line_width = [1,data[:x]].max place_rect = Rect.new(0, 0, line_width, [line_height * 2, Graphics.height].min) contents.blt(xPos, yPos, bitmap, place_rect) bitmap.dispose end #------------------------------------------------------------------------ # Process a character. #------------------------------------------------------------------------ def process_char(char, text, bitmap, line_height, data) if char == "\e" process_special_character(text.slice!(0, 1), text, bitmap, line_height, data) else rect = bitmap.text_size(char) bitmap.draw_text(data[:x], data[:y], rect.width * 2, line_height, char) data[:x]+= rect.width end end #------------------------------------------------------------------------ # Get icon font #------------------------------------------------------------------------ def get_icon_font(font_code) CXJ::HT_CREDITS::ICON_FONTS.each do |icon_font| prefix = icon_font[:prefix] return icon_font if font_code.start_with?(prefix) end return nil end #------------------------------------------------------------------------ # Process a special character. #------------------------------------------------------------------------ def process_special_character(char, text, bitmap, line_height, data) case char when "i", "I" if text.slice(0,2).upcase == "FT" text.slice!(0,2) font_code = text.slice!(/^\[.+?\]/)[/[^\[\]]+/] icon_font = get_icon_font(font_code) return if icon_font.nil? glyph_name = font_code.to_s.clone glyph_name.slice!(0,icon_font[:prefix].size) return if !icon_font[:glyph].has_key?(glyph_name) return_char = eval("\"\\u{" + icon_font[:glyph][glyph_name] + "}\"") current_font_name = bitmap.font.name bitmap.font.name = icon_font[:name] rect = bitmap.text_size(return_char) bitmap.draw_text(data[:x], data[:y], rect.width * 2, line_height, return_char) bitmap.font.name = current_font_name data[:x]+= rect.width end when "c", "C" bitmap.font.color = @credits_data.process_color(text.slice!(0, 8)) when "{" bitmap.font.size += 8 if bitmap.font.size <= 64 when "}" bitmap.font.size -= 8 if bitmap.font.size >= 16 when "a", "A" align = text.slice!(0, 1) case align when "l", "L" data[:align] = 0 when "r", "R" data[:align] = 2 when "c", "C" data[:align] = 1 end when ">" text.slice!(0, 1) when "p", "P" cur_char = text.slice!(0, 1) if cur_char =~ /[0-8]/i data[:pos] = Graphics.width / ((cur_char.to_i - 4) * 2) else case cur_char when "L" data[:pos] = 0 - Graphics.width / 2 when "R" data[:pos] = Graphics.width / 2 when "C" data[:pos] = 0 end end when "u" next_char = text.slice(0, 1) return_char = ''; if next_char != "{" return_char = eval("\"\\u{" + text.slice!(0, 4) + "}\"") else next_char = ""; eval_char = "\"\\u"; while next_char != "}" && !text.empty? next_char = text.slice!(0, 1) eval_char+= next_char end eval_char+= "\""; return_char = eval(eval_char) end rect = bitmap.text_size(return_char) bitmap.draw_text(data[:x], data[:y], rect.width * 2, line_height, return_char) data[:x]+= rect.width end end end class Scene_Credits < Scene_Base #-------------------------------------------------------------------------- # * Start Processing #-------------------------------------------------------------------------- def start super @window_credits = Window_Credits.new end #------------------------------------------------------------------------ # Update #------------------------------------------------------------------------ def update super if (Input.trigger?(:C) && CXJ::HT_CREDITS::ALLOW_MANUAL_CREDITS_CLOSE) || @window_credits.credits_end? @ending = true end if @ending Graphics.brightness = [Graphics.brightness - 16, 0].max if Graphics.brightness == 0 @window_credits.terminate_message SceneManager.return Graphics.brightness = 255 end end end end module CXJ module HT_CREDITS #------------------------------------------------------------------------ # Refresh the credits window. # It will automatically create and open a window if it hasn't. #------------------------------------------------------------------------ def self.refresh(credits_data = nil) if @credits_window.nil? @credits_window = Window_Credits.new(credits_data) @credits_viewport = Viewport.new(0, 0, Graphics.width, Graphics.height) @credits_viewport.z = 300 @credits_window.viewport = @credits_viewport end if (@credits_data.nil? && !credits_data.nil?) || (!credits_data.nil? && @credits_data != credits_data) @credits_data = credits_data @credits_window.set_credits_data(credits_data) end @credits_window.start_message end #------------------------------------------------------------------------ # Update. #------------------------------------------------------------------------ def self.update @credits_window.update if !@credits_window.nil? && @credits_window.visible end #------------------------------------------------------------------------ # Whether the credits have ended or not. #------------------------------------------------------------------------ def self.credits_end? @credits_window.credits_end? end #------------------------------------------------------------------------ # Manually terminates the window. #------------------------------------------------------------------------ def self.terminate_message @credits_window.terminate_message end #------------------------------------------------------------------------ # Gets the opacity of the credits window. #------------------------------------------------------------------------ def self.opacity return @credits_window.contents_opacity end #------------------------------------------------------------------------ # Sets the opacity of the credits window. #------------------------------------------------------------------------ def self.opacity=(value) @credits_window.contents_opacity=value end end end #============================================================================== # ** Scene_Base #------------------------------------------------------------------------------ # This is a super class of all scenes within the game. #============================================================================== class Scene_Base #-------------------------------------------------------------------------- # * Alias: Update Frame (Basic) #-------------------------------------------------------------------------- scene_base_update_basic_cxj_htcredits = instance_method(:update_basic) define_method :update_basic do scene_base_update_basic_cxj_htcredits.bind(self).call CXJ::HT_CREDITS.update end end