Ruby Quellcode

#==============================================================================
# ** Sarah's Configuration Screen
#------------------------------------------------------------------------------
#	by DerVVulfman
#	version 1.1
#	08-09-2014
#	SDK 2.2+ Compliant (Rewrites four audio systems in Game_System)
#------------------------------------------------------------------------------
#
# INTRODUCTION:
#
#   This script is yet another configuration system as you would likely encoun-
#   ter everywhere in the RPGMaker series of forums.  Not much would be differ-
#   ent either, save for the fact this one is virtually plug-and-play and saves
#   a configuration file rather than storing its values within a savegame.
#
#------------------------------------------------------------------------------
#
# FEATURES:
#
#   *  The standard Music and SE Volume control center.
#   *  Enhanced Audio control system for 'battle animation' SE.
#   *  Fullscreen / Windowed toggle system.
#   *  Disables ALT+Enter fullscreen toggle.
#   *  Saves as an outside config file.
#   *  Can be run in-menu or in an event call.
#
#                        	*     	*     	*
#
#   Feature 1:  Standard Music and SE Volume control center.
#   	Like this needs explaining?  You can control the audio level of both
#   	the background music and sound effects that play throughout the game
#   	with this handy pair of scroll bars.
#
#   Feature 2:   Enhanced Audio Control system for 'battle animation' SE.
#   	What some people may not realize is that a configuration script that
#   	controls the audio system in GAME_SYSTEM will not affect the volume
#   	of the SE in battle animations.  The audio in battle animations are
#   	performed within the RPG module's SPRITE class & are barely touched.
#   	Included in this system is my good old 'Battle Animation Audio Fix'.
#   	With it, you have access to the SPRITE class and gain control of the
#   	battle animation's volume.
#
#   Feature 3:  Fullscreen / Windowed toggle system.
#   	I know... I know... there's many a games that have this feature, but
#   	it would be incomplete without one.
#
#   Feature 4:  Disables ALT+Enter fullscreen toggle.
#   	Without this, the player could merely hit the ALT+Enter key to turn on
#   	and off the fullscreen mode.  As this is now added into the system, 
#   	the player will now be forced to use the Fullscreen toggle option.
#
#   Feature 5:  Saves as an outside config file.
#   	Rather than have the system record your audio levels and system set-
#   	tings placed within a savegame,  this system saves them  in a config
#   	file.   This allows the settings to load the moment  the game starts
#   	to run rather  than having the settings load only upon the load of a
#   	saved game.
#
#   Feature 6:  Can be run in-menu or in an event call.
#   	Not much of a feature,  but entertaining none-the-less.  You may use
#   	this call to access the configuration screen:
#
#           	$game_temp.scs_config_calling = true
#           	$scene = Scene_Config.new
#  	
#   	If the $game_temp.scs_config_calling statement is not invokes, then
#   	the system assumes the configuration screen is part of a main menu.
#
#   	With a little more work, an intrepid scripter could have the system
#   	begin before even the TITLE screen loads. ^_^
#
#------------------------------------------------------------------------------
#
#  ADDITIONAL FEATURES:
#
#   I leave those up to you.  This script is meant to be a skeleton for other
#   game creators and one can never account for every wanted nuance.
#
#------------------------------------------------------------------------------
#
#  METHOD LISTINGS:
#
#   Here, I describe the methods used in the script, both those aliased or re-
#   written  and those new.   It is a guide for anyone  using or altering  the
#   system for their tastes.  It will also  give indications  of which scripts
#   were rewritten or merely aliased  after the names of the methods affected.
#
#
#   * RPG::Config
# 	-  initialize
#    	This method creates the startup values that are stored within the
#    	$data_config global object.  When the game first runs, these will
#    	be the overwritten by the default values for the audio  and full-
#    	screen toggle values  recorded in Scene_Title (Scene_Title.main).
#    	As a bonus,  it uses Win32API commands to disable  the use of the 
#    	ALT + ENTER combination, so you may  ONLY  toggle fullscreen from
#    	within the configuration screen.
#   	
#                        	*     	*     	*
#
#   * RPG::Sprite
# 	-  animation_process_timing (REWRITE)
#    	This method adds additional arguments to the Audio.se_play state-
#    	ment, otherwise audio effects from battle animations would not be
#    	altered by the volume control. This was an often overlooked issue
#    	until 2009 when I first introduced the audio fix. ^_^  Yay me!
#
#                        	*     	*     	*
#
#   * Game_Temp
# 	-  initialize (ALIASED)
#    	This method adds a new 'scs_config_calling' variable which should
#    	be turned on (set to true) when the player is calling the command
#    	from the field map.  This was described in 'Feature 5' above.
#
#                        	*     	*     	*
#
#   * Game_System
# 	-  bgm_play (REWRITE)
# 	-  bgs_play (REWRITE)
# 	-  me_play (REWRITE)
# 	-  se_play (REWRITE)
#    	All four  of these methods  were rewritten to include  the volume
#    	control arguments.
#
#                        	*     	*     	*
#
#   * Window_Slider
# 	-  initialize
#    	This value begins the creation of an audio  'slider'  bar window.
#    	It accepts a simple string (text) that informs the bar whether it
#    	is used to adjust music or sound effect volume.  It also sets how
#    	large the font in the window will be adjusted, and sets the range
#    	of the bar from 0 to 100.
#
# 	-  index=
#    	While you can get the index value from a window, this command can
#    	let you set (or reset) the index value. This is used to reset the
#    	volume level and cursor position when the menu is activated.
#
# 	-  refresh
#    	The refresh method is your typical 'draw the window' method.   In
#    	this version, I clear the window, acqyure the configurable values
#    	(to make them visibly manageable),  set the colors of the bar and
#    	cursor.  After that,  I draw the text displaying the percent mar-
#    	kers across the bar, calculate the width of the slider bar,  draw
#    	the slider bar,  figure out the position of the cursor,  and then
#    	draw the cursor. The bulk of the drawing methods were broken into
#    	their own methods to make it easier to manage.
#
# 	-  refresh_percentages
#    	Called from the refresh method (see above), this method draws the
#    	percentage indicator that appears above the bar itself.   It does
#    	so after retrieving  the size  of the font used,  where the first
#    	indicator value (0%) is to appear,and how many pixels across each
#    	indicator is to be spaced.
#
# 	-  refresh_bar
#    	Called from the refresh method (see above), this method draws the
#    	actual slider bar by using three fill_rect values. In succession,
#    	it first draws a large rectangle of one color, a second rectangle
#    	of another color  just within,  and a third rectangle  of another
#    	color within both.
#
# 	-  refresh_cursor
#    	Called from the refresh method (see above), this method draws the
#    	cursor within  the slider bar.   It operates  very much  like the
#    	refresh_bar method,  except it also  accepts an x (left-to-right)
#    	value indicating its position in the bar.
#
# 	-  update
#    	This method is used to allow the player to control the slider bar
#    	itself.  It has checks to ensure it only operates when the window
#    	is active,and exits when the player presses the 'ESC/Cancel' key.
#    	After that,  it turns the window off if the  UP/DOWN  directional
#    	keys are pressed, or runs methods that increases or decreases the
#    	volume settings.  After that,  it copies the volume data into the
#    	appropriate value in the '$data_config' variable object, and then
#    	refreshes the window.
#    	** NOTE:  This does not save the volume data, but only stores it
#              	temporarily in the $data_config variable.  Only if the
#              	player actively SAVES the data, will it be recorded in
#              	the configuration file.
#
# 	-  update_cancel
#    	This method returns a either a true or false value, indicating if
#    	the player has chosen to (true value) exit from the configuration
#    	system, or not (false).  Only when the player hits the 'Input::B'
#    	key will the system deactivate the window and return a true value
#    	to indicate the player is exiting the system.
#
# 	-  update_left and update_right
#    	These methods  lets the player move the volume slider bars to the
#    	left or right,  thus increasing or decreasing  the volume  of the
#    	type of audio it controls.   The bar will either control music or
#    	sound effects afterall. After seeing if the button is pressed, it
#    	does a check to ensure it isn't going outside its range (0-100 or
#    	'0' to '@item_max'). It then branches to either the 'BGM' or 'SE'
#    	set of commands.  For the BGM set, it quickly memorizes and plays
#    	back the music currently playing.   As it does this, the bgm_play
#    	method in Game_System adjusts  the playback volume.   After that,
#    	it then plays the classic 'decision' SE.   But for the SE set, it
#    	merely plays the decision SE effect.   In both cases, it uses the
#    	altered  se_play  system  so the configured volume  for the sound
#    	effects is used.   This method will exit  with a returned  'true' 
#    	value as long  as you slide the bar without trying  to go outside
#    	the volume range, otherwise it returns 'false' and plays a buzzer
#    	sound effect.
#
#                        	*     	*     	*
#
#   * Scene_Title
# 	-  main (ALIASED)
#    	The additions to the 'main' method creates default values for the
#    	volume and fullscreen toggle controls  before it attempts to load
#    	the configuration file. It is HERE that you determine if the game
#    	starts with 100% volume  or if it begins in fullscreen mode.   It
#    	does not create the configuration file, but only checks to see if
#    	one can be loaded.  After that, it performs a 'fullscreen' effect
#    	on the game, but only after seeing if the $data_config.fullscreen
#    	value is set to true. Once that is all done, it performs the rest
#    	of the main method itself.
#
#                        	*     	*     	*
#
#   * Scene_Config
# 	-  initialize
#    	Initially not needed, this sets the index of the options menu to
#    	an index position of '0' (the top of the menu), or lets the game
#    	designer set the index position  when the Config menu is called.
#    	
# 	-  main
#    	This is the basic engine  that runs the configuration menu,  from
#    	beginning to end.  It begins by running the  'initialize windows'
#    	call, a method that creates  the windows in the menu,  performs a
#    	classic transition system, runs a generic  loop...end block,  and
#    	ends after disposing of the windows.
#
# 	-  initialize_windows
#    	Here, we call out to other methods that create their own special-
#    	ized windows in the options menu.  We begin by running the method
#    	that can create a spriteset background which is useful if you in-
#    	tend to show the field map behind the menu.  After that,  we call
#    	the method that  makes a command window,  much like the main menu
#    	in that it gives you a list of options.  We then create an actual
#    	@help_window  object rather than performing  a comand call.  And, 
#    	after that,  we call two more methods that creates our two slider
#    	windows, one for the music and one for sound effects.
#
# 	-  initialize_spriteset
#    	This method creates an object called the @spriteset object.   It
#    	will allow the current field map  to be shown  behind the config
#    	menu.   But before the  @spriteset object  is made,  this method
#    	checks to ensure the script is configured to use a spriteset,and
#    	that the menu was called from the field map.
#
# 	-  initialize_window_command
# 	-  initialize_window_bgm
# 	-  initialize_window_se
#    	These methods create the small windows being shown on the screen
#    	when you start the configuration menu.  Each handles a different
#    	facet, whether it be the  main menu listing the options,  or the
#    	two individual slider menus, each covering either music of sound
#    	effect volumes.   The cursor of the command window can be set to
#    	highlight a specific selection by way of the  @menu_index  value
#    	as set in the initialize method above. However, the index of the
#    	volume slider windows are set based on either the music or sound
#    	effect settings from the $data_config object.
#
# 	-  dispose
#    	This method disposes of the command,  help  and both slider  bar
#    	windows, along with eliminating the  @spriteset window if it was
#    	set to show the field map behind the window.
#
# 	-  update
#    	This method is repeatedly called  from the main method  over and
#    	over, and updates the command window menu. It will either update
#    	the slider window windows  or perform  command menu  operations,
#    	depending on which window within the configuration system is ac-
#    	tive.  It will handle one active window at a time.
#
# 	-  update_help
#    	When this method is called,  it prints a text message within the
#    	help window at the top.  This message will indicate which option
#    	is highlighted in the command menu,  and is keyed to the command
#    	window's index value.
#
# 	-  update_command
#    	Executed by the update method when the command window is active,
#    	this method decides what windows or highlighted options are able
#    	to be executed.  It either turns on one of the two slider volume
#    	windows, or passes control to the methods that toggles the full-
#    	screen window option or saves the configuration data itself.
# 
# 	-  command_toggle_fullscreen
#    	This method only allows execution  if the decision key  has been
#    	pressed.  And if it has, the method will perform a Windows 32API
#    	routine that turns the fullscreen system on/off.  After that, it
#    	changes the flag  used by  the $data_config object  that manages
#    	the fullscreen value.
#
# 	-  command_save
#    	While you can adjust volume and fullscreen/windowed toggles when
#    	playing a game,  you need to save the data.   This function does
#    	precisely that.  It only performs  if the user triggers the deci-
#    	sion key, and when it does,  it opens... writes... and saves the
#    	configuration file.  After that, it checks to see if it was told
#    	to return to the field map, or passes control to the main menu.
#
# 	-  command_debug
#    	When you are in the command window,  you can call the debug sys-
#    	tem by pressing the F9 key as usual .  However,  it does require
#    	the debug calling flag  to be  turned off  and forces the player 
#    	character to be properly straightened (standing still) before it
#    	runs the Scene_Debug system.
#
#
#------------------------------------------------------------------------------
#
#  COMPATABILITY:
#
#   This system should be compatible with other systems, but other systems may
#   hardwire sound effects into themselves.  Scripts that perform 'bell rings'
#   and 'alert buzzes' may need some minor editing by encorporating the follo-
#   wing addendum to a volume setting:
#     	
#           	'volume' * $data_config.se_volume / 100
#
#   This will typically occur only if the other script calls Audio.play_se or
#   similar Audio Module class calls.
#  
#
#============================================================================== 
 
 
 
  # Bar Appearance and Control
  # ==========================
  # This configuration section controls the width of the scrolling bars and
  # the cursor within, along with how many increments are within the bar.
  # ** The width of the drawn bar itself is the width of the cursor multiplied
  #	by the scale value given and by 100.  width = cursor X scale X 100.
  # ---------------------------------------------------------------------------
  #
	SCS_CURSOR_WIDTH  = 18	# Width of the cursor
	SCS_SCALE     	= 2 	# Scaling value for bar width calculation
	SCS_INCREMENTS	= 5 	# Percent SCS_INCREMENTS to scroll (ie 5 = 5%)
 
 
  # Basic Menu Appearance and Control
  # =================================
  # This configuration section handles the basic appearance of the configura-
  # tion menu, dealing with both font size and if the field map is shown through
  # the menu itself.  It also lets you identify which main menu option to high-
  # light if you are returning from the configuration menu to the main menu.
  # ---------------------------------------------------------------------------
  #
	SCS_FONT_SIZE 	= 24	# Size of the font used in the screen
	SCS_SPRITESET 	= true  # If Fieldmap background shows through
	SES_EXIT      	= 4 	# Return to main menu option: Scene_Menu.new(4)
 
 
  # Filename
  # ========
  # Not much to be said.  This determines the actual name of your game's con-
  # figuration file.
  # ---------------------------------------------------------------------------
  #
	SCS_FILENAME  	= "MyGame.cfg"
 
 
 
#==============================================================================
# ** RPG
#------------------------------------------------------------------------------
#  A module containing RPGXP's data structures and more.
#==============================================================================
 
module RPG
 
  #============================================================================
  # ** Config
  #----------------------------------------------------------------------------
  #  A module containing the configuration file's data structure
  #============================================================================
  class Config
	#--------------------------------------------------------------------------
	# * Win32API Definitions
	#--------------------------------------------------------------------------	
	RegHotKey   = Win32API.new('user32','RegisterHotKey', 'liii', 'i')
	FindWindow  = Win32API.new('user32','FindWindowEx', %w(l l p p), 'i')
	#--------------------------------------------------------------------------
	# * Public Instance Variables
	#--------------------------------------------------------------------------	
	attr_accessor :bgm_volume
	attr_accessor :se_volume
	attr_accessor :fullscreen
	#--------------------------------------------------------------------------
	# * Public Instance Variables
	#--------------------------------------------------------------------------	
	def initialize
  	# Startup values
  	bgm_volume  = 100
  	se_volume   = 100
  	fullscreen  = false
  	# Turn off Alt+Enter system (only allow config version)
  	hwnd = FindWindow.call(0,0,"RGSS Player",0)
  	RegHotKey.call(hwnd, 1, 0x0001, 0x0D)
	end
  end
end
 
 
 
#--------------------------------------------------------------------------
# * Global Array Initialization
#-------------------------------------------------------------------------- 
$data_config = RPG::Config.new
 
 
 
#==============================================================================
# ** EDIT:  Animation Audio Fix
#------------------------------------------------------------------------------
#  This update to the Animation Timer allows for volume adjustment through the
#  Options Menu.  Without this module, all battle animations would be at full
#  volume.
#==============================================================================
 
module RPG
  class Sprite < ::Sprite
	def animation_process_timing(timing, hit)
  	if (timing.condition == 0) or
     	(timing.condition == 1 and hit == true) or
     	(timing.condition == 2 and hit == false)
    	if timing.se.name != ""
      	se = timing.se
      	Audio.se_play("Audio/SE/" + se.name, 
        	se.volume * $data_config.se_volume / 100 , se.pitch)
    	end
    	case timing.flash_scope
    	when 1
      	self.flash(timing.flash_color, timing.flash_duration * 2)
    	when 2
      	if self.viewport != nil
        	self.viewport.flash(timing.flash_color, timing.flash_duration * 2)
      	end
    	when 3
      	self.flash(nil, timing.flash_duration * 2)
    	end
  	end
	end
  end
end
 
 
 
#==============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
#  This class handles temporary data that is not included with save data.
#  Refer to "$game_temp" for the instance of this class.
#==============================================================================
 
class Game_Temp
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :scs_config_calling       	# option calling flag
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias scs_config_init initialize
  def initialize  
	scs_config_init
	@scs_config_calling = false	
  end
end
 
 
 
#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles data surrounding the system. Backround music, etc.
#  is managed here as well. Refer to "$game_system" for the instance of 
#  this class.
#==============================================================================
 
class Game_System
  #--------------------------------------------------------------------------
  # * Play Background Music
  # 	bgm : background music to be played
  #--------------------------------------------------------------------------
  def bgm_play(bgm)
	@playing_bgm = bgm
	if bgm != nil and bgm.name != ""
  	Audio.bgm_play("Audio/BGM/"+ bgm.name, 
    	bgm.volume * $data_config.bgm_volume / 100 , bgm.pitch)
	else
  	Audio.bgm_stop
	end
	Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # * Play Background Sound
  # 	bgs : background sound to be played
  #--------------------------------------------------------------------------
  def bgs_play(bgs)
	@playing_bgs = bgs
	if bgs != nil and bgs.name != ""
  	Audio.bgs_play("Audio/BGS/" + bgs.name, 
    	bgs.volume * $data_config.se_volume / 100, bgs.pitch)
	else
  	Audio.bgs_stop
	end
	Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # * Play Music Effect
  # 	me : music effect to be played
  #--------------------------------------------------------------------------
  def me_play(me)
	if me != nil and me.name != ""
  	Audio.me_play("Audio/ME/"+me.name, 
    	me.volume * $data_config.bgm_volume / 100, me.pitch)
	else
  	Audio.me_stop
	end
	Graphics.frame_reset
  end	
  #--------------------------------------------------------------------------
  # * Play Sound Effect
  # 	se : sound effect to be played
  #--------------------------------------------------------------------------
  def se_play(se)
	if se != nil and se.name != ""
  	Audio.se_play("Audio/SE/"+se.name,
    	se.volume * $data_config.se_volume / 100 ,se.pitch)
	end
  end  
end
 
 
 
#==============================================================================
# ** Window_Slider
#------------------------------------------------------------------------------
#  This window displays a slider bar for use in configuration control systems.
#==============================================================================
 
class Window_Slider < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	text   : text in slider window
  #--------------------------------------------------------------------------
  def initialize(text = "")
	super(0, 0, 380, 120)
	self.contents       	= Bitmap.new(width - 32, height - 32)
	self.contents.font.size = SCS_FONT_SIZE
	self.active         	= false
	@text               	= text
	@index              	= 0   	if @index.nil?
	@item_max           	= 100
	self.visible        	= false
	refresh
  end
  #--------------------------------------------------------------------------
  # * Set Cursor Position
  # 	index : new cursor position
  #--------------------------------------------------------------------------
  def index=(index)
	@index = index
	refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
	self.contents.clear                                   	# Clear Contents
	# Handle configurables
	font_size 	= SCS_FONT_SIZE                         	# Font Size
	cursor_width  = SCS_CURSOR_WIDTH                      	# Cursor Width
	scale     	= SCS_SCALE                             	# Scale Size
	# Handle bar colors
	outer_border  = Color.new(100,200,200,140)            	# Bar
	inner_border  = Color.new( 28,128,128,190)            	# Borders
	fill      	= Color.new( 64, 64, 64,190)            	# And Fill Colors
	cur_border	= Color.new(100,100,100,215)            	# Cursor Border
	cur_fill  	= Color.new( 90, 90, 90,215)            	# Cursor Fill 
	# Handle bar calculations and display
	refresh_percentages(font_size, 32, 50)                	# Draw Percentages
	bar_width = @item_max * scale + cursor_width          	# Calc bar width
	refresh_bar(bar_width, outer_border, inner_border, fill)  # Draw Bar
	x = (@index * (@item_max * scale) ) / @item_max + 36  	# Calculate X
	refresh_cursor(x, cursor_width, cur_border, cur_fill) 	# Draw Cursor
  end
  #--------------------------------------------------------------------------
  # * Refresh percentage text
  #--------------------------------------------------------------------------
  def refresh_percentages(font_size, start, incr)
	self.contents.draw_text(  0,  0, 128, font_size, @text + " volume", 0)
	self.contents.draw_text(start * (incr*0), 60,  80, font_size,   "0%")
	self.contents.draw_text(start * (incr*1), 60,  80, font_size,  "25%")
	self.contents.draw_text(start * (incr*2), 60,  80, font_size,  "50%")
	self.contents.draw_text(start * (incr*3), 60,  80, font_size,  "75%")
	self.contents.draw_text(start * (incr*4), 60,  80, font_size, "100%")
  end
  #--------------------------------------------------------------------------
  # * Refresh bar
  #--------------------------------------------------------------------------
  def refresh_bar(width, outer, inner, fill)
	self.contents.fill_rect(32, 30, width + 8, 20, outer)
	self.contents.fill_rect(34, 32, width + 4, 16, inner)
	self.contents.fill_rect(36, 34, width, 	12, fill)
  end
  #--------------------------------------------------------------------------
  # * Refresh cursor
  #--------------------------------------------------------------------------
  def refresh_cursor(x, width, border, fill)
	self.contents.fill_rect(x,   33, width,  14, border)
	self.contents.fill_rect(x+4, 36, width-8, 8, fill)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Exit method checks
	return unless self.active                     	# End method unless active
	return if update_cancel                       	# Deactivate if Cancel
	# Cursor Control Actions
	self.active = false if Input.repeat?(Input::UP)   # Deactivate if UP
	self.active = false if Input.repeat?(Input::DOWN) # Deactivate if DOWN
	return if update_left                         	# Decrease Bar if LEFT
	return if update_right                        	# Increase Bar if RIGHT
	# Adjust volume values based on bar
	case @text                                    	# Branch based on Text
	when "BGM" ; $data_config.bgm_volume = @index 	# Accept new BGM data
	when "SE"  ; $data_config.se_volume = @index  	# Accept new SE data
	end                                           	# End Branch
	refresh                                       	# And refresh the Slider
  end
  #--------------------------------------------------------------------------
  # * Frame Update (When detecting Cancel/Escape)
  #--------------------------------------------------------------------------
  def update_cancel
	return false unless Input.repeat?(Input::B)   # Exit false unless B pressed
	self.active = false                       	# Deactivate the window
	return true                               	# And return control true
  end
  #--------------------------------------------------------------------------
  # * Frame Update (When detecting LEFT key to decrease bar)
  #--------------------------------------------------------------------------
  def update_left
	return false unless Input.repeat?(Input::LEFT)    	# Exit unless LEFT
	if @index != 0                                    	# Perform unless 0 vol
  	case @text                                      	# Branch on sound type
  	when "BGM"                                      	# Handle BGM case
    	@index -= SCS_INCREMENTS                      	# Reduce Bar
    	$game_system.bgm_play($game_system.bgm_memorize)  # Play memorized music
    	$game_system.se_play($data_system.decision_se)	# Play Decision SE
  	when "SE"                                       	# Handle SE case
    	$game_system.se_play($data_system.decision_se)	# Play Decision SE
    	@index -= SCS_INCREMENTS                      	# Reduce Bar
  	end                                             	# End of Branch
  	return true                                     	# Return True
	end                                               	# End ...if case
	$game_system.se_play($data_system.buzzer_se)      	# Play buzzer SE
	return false                                      	# Return False
  end
  #--------------------------------------------------------------------------
  # * Frame Update (When detecting RIGHT key to increase bar)
  #--------------------------------------------------------------------------
  def update_right
	# If RIGHT button was pressed
	return false unless Input.repeat?(Input::RIGHT)   	# Exit unless RIGHT
	if @index < @item_max                             	# Perform unless maxed
  	case @text                                      	# Branch on sound type
  	when "BGM"                                      	# Handle BGM Case
    	@index += SCS_INCREMENTS                      	# Increase bar
    	$game_system.bgm_play($game_system.bgm_memorize)  # Play memorized music
    	$game_system.se_play($data_system.decision_se)	# Play Decision SE
  	when "SE"                                       	# Handle SE case
    	$game_system.se_play($data_system.decision_se)	# Play Decision SE
    	@index += SCS_INCREMENTS                      	# Increase bar
  	end                                             	# End of Branch
  	return true                                     	# Return true
	end                                               	# End ...if case
	$game_system.se_play($data_system.buzzer_se)      	# Play buzzer SE
	return false                                      	# Return false
  end
end
 
 
 
#==============================================================================
# ** Scene_Title
#------------------------------------------------------------------------------
#  This class performs title screen processing.
#==============================================================================
 
class Scene_Title
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  alias scs_config_main main
  def main
	# Establish default config values
	$data_config.bgm_volume = 100
	$data_config.se_volume  = 100
	$data_config.fullscreen = false
	# Load Config if config file exists
	if FileTest.exist?(SCS_FILENAME)
  	$data_config = load_data(SCS_FILENAME)	
	end
	# Reset screen mode if config set to fullscreen
	if $data_config.fullscreen == true
  	showm = Win32API.new 'user32', 'keybd_event', %w(l l l l), ''
  	showm.call(18,0,0,0) ; showm.call(13,0,0,0)
  	showm.call(13,0,2,0) ; showm.call(18,0,2,0)  	
	end
	# Perform the original call
	scs_config_main
  end
end
 
 
 
#==============================================================================
# ** Scene_Config
#------------------------------------------------------------------------------
#  This class performs configuration system option processing.
#==============================================================================
 
class Scene_Config
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
	@menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	initialize_windows            	# Create the windows
	Graphics.transition           	# Execute transition
	loop do                       	# Begin the main loop
  	Graphics.update             	# Update game screen
  	Input.update                	# Update input information
  	update                      	# Frame update
  	break if $scene != self     	# Abort loop if screen is changed
	end                           	# End the main loop and restart
	Graphics.freeze               	# Prepare for transition
	dispose                       	# Dispose of windows
  end
  #--------------------------------------------------------------------------
  # * Initialize Windows
  #--------------------------------------------------------------------------
  def initialize_windows
	initialize_spriteset          	# Make a spriteset window
	initialize_window_command     	# Make command window
	@help_window  = Window_Help.new   # Make help window
	initialize_window_bgm         	# Make background music window
	initialize_window_se          	# Make sound effect window
  end
  #--------------------------------------------------------------------------
  # * Initialize Spriteset
  #--------------------------------------------------------------------------
  def initialize_spriteset
	return unless SCS_SPRITESET == true         	# Only if configured
	return unless $game_temp.debug_calling == true  # Only if from map
	@spriteset = Spriteset_Map.new              	# Create spriteset
  end
  #--------------------------------------------------------------------------
  # * Initialize Window : Command Window
  #--------------------------------------------------------------------------
  def initialize_window_command
	s1	= "Music Volume"                            	# Make a music option
	s2	= "Sound Volume"                            	# Make a sound option
	s3	= "Window Mode"                             	# Make a window option
	s4	= "Exit"                                    	# Make an exit option
	list  = [s1, s2, s3, s4]                          	# Make the menu list
	@command_window   	= Window_Command.new(260, list) # Make the menu
	@command_window.y 	= 64                        	# Move it vertically
	@command_window.index = @menu_index               	# Highlight an option
  end
  #--------------------------------------------------------------------------
  # * Initialize Window : BGM Slider
  #--------------------------------------------------------------------------
  def initialize_window_bgm
	@bgm_window     	= Window_Slider.new("BGM")  # Make a window for BGM
	@bgm_window.index   = $data_config.bgm_volume   # Set the cursor position
	@bgm_window.x   	= 260                   	# Move the window horiz...
	@bgm_window.y   	= 64                    	# Move the window vert...
	@bgm_window.visible = true                  	# Make it visible
  end
  #--------------------------------------------------------------------------
  # * Initialize Window : SE Slider
  #--------------------------------------------------------------------------
  def initialize_window_se
	@se_window      	= Window_Slider.new("SE")   # Make a window for SEs
	@se_window.index	= $data_config.se_volume	# Set the cursor position
	@se_window.x    	= 260                   	# Move the window horiz...
	@se_window.y    	= 184                   	# Move the window vert...
	@se_window.visible  = true                  	# Make it visible
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
	@spriteset.dispose unless @spriteset.nil?   	# Erase the fieldmap sprite
	@command_window.dispose                     	# set if it exists, and then
	@help_window.dispose                        	# erase all other config
	@bgm_window.dispose                         	# menu windows.
	@se_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	@command_window.update                          	# Update command window
	command_debug         	if $DEBUG             	# Update debug commands
	return @bgm_window.update if @bgm_window.active 	# Update BGM if active
	return @se_window.update  if @se_window.active  	# Update SE if active
	return update_command 	if @command_window.active # Update commands
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update_help
	case @command_window.index
	when 0; @help_window.set_text("Set the volume of the background music.",1)
	when 1; @help_window.set_text("Set the volume of audible sound effects.",1)
	when 2; @help_window.set_text("Toggle Fullscreen / Windowed Game Screen.",1)
	when 3; @help_window.set_text("Return to Menu.",1)
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
	update_help                       	# Update the help window.
	case @command_window.index        	# Branch based on command selected.
	when 0 ; @bgm_window.active = true	# Make BGM window active.
	when 1 ; @se_window.active  = true	# Make SE window active.
	when 2 ; command_toggle_fullscreen	# Run Fullscreen Toggle method.
	when 3 ; command_save             	# Run Save and Exit method.
	end
  end
  #--------------------------------------------------------------------------
  # * Command Action:  (performing Fullscreen / Window Toggle)
  #--------------------------------------------------------------------------
  def command_toggle_fullscreen
	return unless Input.trigger?(Input::C)      	# Abort unless C is pressed.
	$game_system.se_play($data_system.decision_se)  # Play the decision SE.
	showm = Win32API.new 'user32', 'keybd_event',   # One of a few fullscreen
                     	%w(l l l l), ''        	# toggle methods that I've 
	showm.call(18,0,0,0) ; showm.call(13,0,0,0) 	# seen.  It performs some
	showm.call(13,0,2,0) ; showm.call(18,0,2,0) 	# pseudo keyboard presses.
	if $data_config.fullscreen == true          	# If the flag is set to true
  	$data_config.fullscreen = nil             	# Turn off the flag
	else                                        	# Otherwise
  	$data_config.fullscreen = true            	# turn it on
	end                                         	# And be done with it.
  end
  #--------------------------------------------------------------------------
  # * Command Action:  (performing Save and Exit)
  #--------------------------------------------------------------------------
  def command_save
	return unless Input.trigger?(Input::C)      	# Abort unless C pressed
	$game_system.se_play($data_system.decision_se)  # Play the decision SE
	file = File.open(SCS_FILENAME, "wb")        	# Open the config data file
	Marshal.dump($data_config, file)            	# Write the data to the file
	file.close                                  	# And close the file
	if $game_temp.scs_config_calling            	# If called from event
  	$game_temp.scs_config_calling = false     	# Clear save call flag
  	$scene = Scene_Map.new                    	# Switch to map screen
  	return                                    	# And End Method
	end                                         	# End of ...if decision
	$scene = Scene_Menu.new(SES_EXIT)           	# Switch to menu screen
  end
  #--------------------------------------------------------------------------
  # * Command Action:  (performing Debug Call)
  #--------------------------------------------------------------------------
  def command_debug
	return unless Input.press?(Input::F9)       	# Abort unless F9 pressed
	$game_temp.debug_calling = false            	# Clear debug call flag
	$game_system.se_play($data_system.decision_se)  # Play decision SE
	$game_player.straighten                     	# Straighten player
	$scene = Scene_Debug.new                    	# Switch to debug screen
  end
end