1013 lines
36 KiB
Ruby
1013 lines
36 KiB
Ruby
#==============================================================================
|
|
#
|
|
# GaryCXJk - Hacked Together Credits Script v1.02
|
|
# * Last Updated: 2014.08.03
|
|
# * Level: Easy
|
|
# * Requires: N/A
|
|
#
|
|
#==============================================================================
|
|
|
|
|
|
#==============================================================================
|
|
#
|
|
# 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 = System_Settings::MESSAGE_WINDOW_FONT_NAME # 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 = ["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.exist?(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
|
|
self.z = System_Settings::SCENE_CREDIT_TEXT_Z
|
|
@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 = System_Settings::FONT_SIZE::SCENE_CREDIT_BASIC
|
|
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,200)
|
|
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.font.outline = false
|
|
|
|
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 += System_Settings::FONT_SIZE::SCENE_CREDIT_SWITCH if bitmap.font.size <= System_Settings::FONT_SIZE::SCENE_CREDIT_MAX
|
|
when "}"
|
|
bitmap.font.size -= System_Settings::FONT_SIZE::SCENE_CREDIT_SWITCH if bitmap.font.size >= System_Settings::FONT_SIZE::SCENE_CREDIT_MAX
|
|
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_Map
|
|
#--------------------------------------------------------------------------
|
|
# * Start Processing
|
|
#--------------------------------------------------------------------------
|
|
def start
|
|
$loading_screen.dispose if $loading_screen
|
|
if $game_player.force_update == true
|
|
#$game_party.setup_starting_members
|
|
$game_map.setup($data_tag_maps["Credit"].sample)
|
|
$game_player.moveto(1,1)
|
|
#$game_player.opacity = 0
|
|
$game_portraits.lprt.hide
|
|
$game_portraits.rprt.hide
|
|
#$game_player.followers.visible = false
|
|
#$game_player.refresh
|
|
#$game_player.make_encounter_count
|
|
|
|
#@character_name = $game_player.character_name
|
|
#@character_index = $game_player.character_index
|
|
$game_player.force_update = false
|
|
Graphics.frame_count = 0
|
|
end
|
|
|
|
super
|
|
draw_TheEnd_mode
|
|
$game_system.menu_disabled = true
|
|
@hud.hide
|
|
@window_credits = Window_Credits.new
|
|
$game_map.clear_fog
|
|
@rebirthWait= 120
|
|
$hudForceHide = true
|
|
$hudForceHideAll = true
|
|
$balloonForceHide = true
|
|
end
|
|
|
|
def draw_TheEnd_mode
|
|
tmpW=Graphics.width
|
|
tmpH=Graphics.height
|
|
@foreground_TheEnd = Sprite.new
|
|
@foreground_TheEnd.bitmap = Bitmap.new(Graphics.width, Graphics.height)
|
|
@foreground_TheEnd.z = System_Settings::TITLE_FOREGROUND_Z
|
|
@foreground_TheEnd.bitmap.font.size = System_Settings::FONT_SIZE::SCENE_CREDIT_END
|
|
@foreground_TheEnd.bitmap.font.outline = false
|
|
rect = Rect.new(0, (tmpH/2)-40, Graphics.width-10,60)
|
|
@foreground_TheEnd.bitmap.draw_text(rect,"THANKS FOR PLAYING", 1)
|
|
@foreground_TheEnd.opacity = 0
|
|
end
|
|
#------------------------------------------------------------------------
|
|
# Update
|
|
#------------------------------------------------------------------------
|
|
def update
|
|
super
|
|
if Input.trigger?(:B) || Input.trigger?(:C) || WolfPad.trigger?(:X_LINK) || WolfPad.trigger?(:Z_LINK) || Input.trigger?(:MX_LINK) || Input.trigger?(:MZ_LINK)#&& CXJ::HT_CREDITS::ALLOW_MANUAL_CREDITS_CLOSE) || @window_credits.credits_end?
|
|
@ending = true
|
|
end
|
|
@foreground_TheEnd.opacity +=1 if @window_credits.credits_end? && @foreground_TheEnd.opacity < 200
|
|
@window_credits.terminate_message if @foreground_TheEnd.opacity >= 200 && @credits_running == true
|
|
if @ending
|
|
@window_credits.credits_end? ? SndLib.ppl_Cheer : SndLib.ppl_Boo
|
|
@foreground_TheEnd.dispose
|
|
@window_credits.terminate_message
|
|
fadeout_all
|
|
if $inheritance
|
|
$game_player.force_update = false
|
|
DataManager.setup_new_game(true,"NoerSewer")
|
|
$inheritance = nil
|
|
SceneManager.goto(Scene_Map)
|
|
GabeSDK.getAchievement("Rebirth")
|
|
else
|
|
$game_player.force_update = true
|
|
SceneManager.goto(Scene_MapTitle)
|
|
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
|