Transparentes Menü

Ankömmling

Freitag, 22. April 2011, 17:27

Transparentes Menü

Hallo,

ich suche nach einem Skript, mit dem das menü halb durchsichtig wird und somit die map und der player etc. verschwommen noch zu sehen sind wenn man das menü aufruft, so wie beim rmvx. würde mich sehr freuen ob jemand ein solches skript zur verfügung stellen kann und bedanke mich schonmal.

mfg
Blue Dragon

Asandril

Landsknecht

Samstag, 23. April 2011, 12:13

Ich habe dir mal ein Transparentes Menu zusammengebastelt.
Füge das Script separat über Main ein(Nicht in das Main).

Spoiler

Ruby Quellcode

#==============================================================================
# ** Scene_Menu Transparent
#------------------------------------------------------------------------------
#  This class performs menu screen processing.
#==============================================================================
 
class Scene_Menu 
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
	@menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Make command window
	s1 = $data_system.words.item
	s2 = $data_system.words.skill
	s3 = $data_system.words.equip
	s4 = "Status"
	s5 = "Save"
	s6 = "End Game"
	@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
	@command_window.back_opacity = 160
	@command_window.index = @menu_index
	# If number of party members is 0
	if $game_party.actors.size == 0
  	# Disable items, skills, equipment, and status
  	@command_window.disable_item(0)
  	@command_window.disable_item(1)
  	@command_window.disable_item(2)
  	@command_window.disable_item(3)
	end
	# If save is forbidden
	if $game_system.save_disabled
  	# Disable save
  	@command_window.disable_item(4)
	end
	# Make play time window
	@playtime_window = Window_PlayTime.new
	@playtime_window.opacity = 160   
	@playtime_window.x = 0
	@playtime_window.y = 224
	# Make steps window
	@steps_window = Window_Steps.new
	@steps_window.opacity = 160   
	@steps_window.x = 0
	@steps_window.y = 320
	# Make gold window
	@gold_window = Window_Gold.new
	@gold_window.opacity = 160   
	@gold_window.x = 0
	@gold_window.y = 416
	# Make status window
	@status_window = Window_MenuStatus.new
	@status_window.opacity = 160  
	@status_window.x = 160
	@status_window.y = 0
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@command_window.dispose
	@playtime_window.dispose
	@steps_window.dispose
	@gold_window.dispose
	@status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@command_window.update
	@playtime_window.update
	@steps_window.update
	@gold_window.update
	@status_window.update
	# If command window is active: call update_command
	if @command_window.active
  	update_command
  	return
	end
	# If status window is active: call update_status
	if @status_window.active
  	update_status
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to map screen
  	$scene = Scene_Map.new
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If command other than save or end game, and party members = 0
  	if $game_party.actors.size == 0 and @command_window.index < 4
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Branch by command window cursor position
  	case @command_window.index
  	when 0  # item
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to item screen
    	$scene = Scene_Item.new
  	when 1  # skill
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Make status window active
    	@command_window.active = false
    	@status_window.active = true
    	@status_window.index = 0
  	when 2  # equipment
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Make status window active
    	@command_window.active = false
    	@status_window.active = true
    	@status_window.index = 0
  	when 3  # status
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Make status window active
    	@command_window.active = false
    	@status_window.active = true
    	@status_window.index = 0
  	when 4  # save
    	# If saving is forbidden
    	if $game_system.save_disabled
      	# Play buzzer SE
      	$game_system.se_play($data_system.buzzer_se)
      	return
    	end
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to save screen
    	$scene = Scene_Save.new
  	when 5  # end game
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to end game screen
    	$scene = Scene_End.new
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when status window is active)
  #--------------------------------------------------------------------------
  def update_status
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Make command window active
  	@command_window.active = true
  	@status_window.active = false
  	@status_window.index = -1
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Branch by command window cursor position
  	case @command_window.index
  	when 1  # skill
    	# If this actor's action limit is 2 or more
    	if $game_party.actors[@status_window.index].restriction >= 2
      	# Play buzzer SE
      	$game_system.se_play($data_system.buzzer_se)
      	return
    	end
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to skill screen
    	$scene = Scene_Skill.new(@status_window.index)
  	when 2  # equipment
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to equipment screen
    	$scene = Scene_Equip.new(@status_window.index)
  	when 3  # status
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to status screen
    	$scene = Scene_Status.new(@status_window.index)
  	end
  	return
	end
  end
end
class Scene_Map
  def main
	@spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
	Graphics.transition
	loop do
  	Graphics.update
  	Input.update
  	update
  	if $scene != self
    	break
  	end
	end
	Graphics.freeze
	@message_window.dispose
	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
  end
end
#==============================================================================
# ** Scene_Item
#------------------------------------------------------------------------------
#  This class performs item screen processing.
#==============================================================================
 
class Scene_Item
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Make help window, item window
	@help_window = Window_Help.new
	@item_window = Window_Item.new
	@help_window.opacity = 160  
	@item_window.opacity = 160  
	# Associate help window
	@item_window.help_window = @help_window
	# Make target window (set to invisible / inactive)
	@target_window = Window_Target.new
	@target_window.visible = false
	@target_window.active = false
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@item_window.dispose
	@target_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@help_window.update
	@item_window.update
	@target_window.update
	# If item window is active: call update_item
	if @item_window.active
  	update_item
  	return
	end
	# If target window is active: call update_target
	if @target_window.active
  	update_target
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(0)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Get currently selected data on the item window
  	@item = @item_window.item
  	# If not a use item
  	unless @item.is_a?(RPG::Item)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# If it can't be used
  	unless $game_party.item_can_use?(@item.id)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# If effect scope is an ally
  	if @item.scope >= 3
    	# Activate target window
    	@item_window.active = false
    	@target_window.x = (@item_window.index + 1) % 2 * 304
    	@target_window.visible = true
    	@target_window.active = true
    	# Set cursor position to effect scope (single / all)
    	if @item.scope == 4 || @item.scope == 6
      	@target_window.index = -1
    	else
      	@target_window.index = 0
    	end
  	# If effect scope is other than an ally
  	else
    	# If command event ID is valid
    	if @item.common_event_id > 0
      	# Command event call reservation
      	$game_temp.common_event_id = @item.common_event_id
      	# Play item use SE
      	$game_system.se_play(@item.menu_se)
      	# If consumable
      	if @item.consumable
        	# Decrease used items by 1
        	$game_party.lose_item(@item.id, 1)
        	# Draw item window item
        	@item_window.draw_item(@item_window.index)
      	end
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# If unable to use because items ran out
  	unless $game_party.item_can_use?(@item.id)
    	# Remake item window contents
    	@item_window.refresh
  	end
  	# Erase target window
  	@item_window.active = true
  	@target_window.visible = false
  	@target_window.active = false
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If items are used up
  	if $game_party.item_number(@item.id) == 0
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# If target is all
  	if @target_window.index == -1
    	# Apply item effects to entire party
    	used = false
    	for i in $game_party.actors
      	used |= i.item_effect(@item)
    	end
  	end
  	# If single target
  	if @target_window.index >= 0
    	# Apply item use effects to target actor
    	target = $game_party.actors[@target_window.index]
    	used = target.item_effect(@item)
  	end
  	# If an item was used
  	if used
    	# Play item use SE
    	$game_system.se_play(@item.menu_se)
    	# If consumable
    	if @item.consumable
      	# Decrease used items by 1
      	$game_party.lose_item(@item.id, 1)
      	# Redraw item window item
      	@item_window.draw_item(@item_window.index)
    	end
    	# Remake target window contents
    	@target_window.refresh
    	# If all party members are dead
    	if $game_party.all_dead?
      	# Switch to game over screen
      	$scene = Scene_Gameover.new
      	return
    	end
    	# If common event ID is valid
    	if @item.common_event_id > 0
      	# Common event call reservation
      	$game_temp.common_event_id = @item.common_event_id
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	# If item wasn't used
  	unless used
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Skill
#------------------------------------------------------------------------------
#  This class performs skill screen processing.
#==============================================================================
 
class Scene_Skill
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make help window, status window, and skill window
	@help_window = Window_Help.new
	@help_window.opacity = 160  
	@status_window = Window_SkillStatus.new(@actor)
	@status_window.opacity = 160  
	@skill_window = Window_Skill.new(@actor)
	@skill_window.opacity = 160  
	# Associate help window
	@skill_window.help_window = @help_window
	# Make target window (set to invisible / inactive)
	@target_window = Window_Target.new
	@target_window.visible = false
	@target_window.active = false
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@status_window.dispose
	@skill_window.dispose
	@target_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@help_window.update
	@status_window.update
	@skill_window.update
	@target_window.update
	# If skill window is active: call update_skill
	if @skill_window.active
  	update_skill
  	return
	end
	# If skill target is active: call update_target
	if @target_window.active
  	update_target
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if skill window is active)
  #--------------------------------------------------------------------------
  def update_skill
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(1)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Get currently selected data on the skill window
  	@skill = @skill_window.skill
  	# If unable to use
  	if @skill == nil or not @actor.skill_can_use?(@skill.id)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# If effect scope is ally
  	if @skill.scope >= 3
    	# Activate target window
    	@skill_window.active = false
    	@target_window.x = (@skill_window.index + 1) % 2 * 304
    	@target_window.visible = true
    	@target_window.active = true
    	# Set cursor position to effect scope (single / all)
    	if @skill.scope == 4 || @skill.scope == 6
      	@target_window.index = -1
    	elsif @skill.scope == 7
      	@target_window.index = @actor_index - 10
    	else
      	@target_window.index = 0
    	end
  	# If effect scope is other than ally
  	else
    	# If common event ID is valid
    	if @skill.common_event_id > 0
      	# Common event call reservation
      	$game_temp.common_event_id = @skill.common_event_id
      	# Play use skill SE
      	$game_system.se_play(@skill.menu_se)
      	# Use up SP
      	@actor.sp -= @skill.sp_cost
      	# Remake each window content
      	@status_window.refresh
      	@skill_window.refresh
      	@target_window.refresh
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different skill screen
  	$scene = Scene_Skill.new(@actor_index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different skill screen
  	$scene = Scene_Skill.new(@actor_index)
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Erase target window
  	@skill_window.active = true
  	@target_window.visible = false
  	@target_window.active = false
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If unable to use because SP ran out
  	unless @actor.skill_can_use?(@skill.id)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# If target is all
  	if @target_window.index == -1
    	# Apply skill use effects to entire party
    	used = false
    	for i in $game_party.actors
      	used |= i.skill_effect(@actor, @skill)
    	end
  	end
  	# If target is user
  	if @target_window.index <= -2
    	# Apply skill use effects to target actor
    	target = $game_party.actors[@target_window.index + 10]
    	used = target.skill_effect(@actor, @skill)
  	end
  	# If single target
  	if @target_window.index >= 0
    	# Apply skill use effects to target actor
    	target = $game_party.actors[@target_window.index]
    	used = target.skill_effect(@actor, @skill)
  	end
  	# If skill was used
  	if used
    	# Play skill use SE
    	$game_system.se_play(@skill.menu_se)
    	# Use up SP
    	@actor.sp -= @skill.sp_cost
    	# Remake each window content
    	@status_window.refresh
    	@skill_window.refresh
    	@target_window.refresh
    	# If entire party is dead
    	if $game_party.all_dead?
      	# Switch to game over screen
      	$scene = Scene_Gameover.new
      	return
    	end
    	# If command event ID is valid
    	if @skill.common_event_id > 0
      	# Command event call reservation
      	$game_temp.common_event_id = @skill.common_event_id
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	# If skill wasn't used
  	unless used
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Equip
#------------------------------------------------------------------------------
#  This class performs equipment screen processing.
#==============================================================================
 
class Scene_Equip
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  # 	equip_index : equipment index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
	@equip_index = equip_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make windows
	@help_window = Window_Help.new
	@help_window.opacity = 160  
	@left_window = Window_EquipLeft.new(@actor)
	@left_window.opacity = 160  
	@right_window = Window_EquipRight.new(@actor)
	@right_window.opacity = 160  
	@item_window1 = Window_EquipItem.new(@actor, 0)
	@item_window1.opacity = 160  
	@item_window2 = Window_EquipItem.new(@actor, 1)
	@item_window2.opacity = 160  
	@item_window3 = Window_EquipItem.new(@actor, 2)
	@item_window3.opacity = 160  
	@item_window4 = Window_EquipItem.new(@actor, 3)
	@item_window4.opacity = 160  
	@item_window5 = Window_EquipItem.new(@actor, 4)
	@item_window5.opacity = 160  
	# Associate help window
	@right_window.help_window = @help_window
	@item_window1.help_window = @help_window
	@item_window2.help_window = @help_window
	@item_window3.help_window = @help_window
	@item_window4.help_window = @help_window
	@item_window5.help_window = @help_window
	# Set cursor position
	@right_window.index = @equip_index
	refresh
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@left_window.dispose
	@right_window.dispose
	@item_window1.dispose
	@item_window2.dispose
	@item_window3.dispose
	@item_window4.dispose
	@item_window5.dispose
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
	# Set item window to visible
	@item_window1.visible = (@right_window.index == 0)
	@item_window2.visible = (@right_window.index == 1)
	@item_window3.visible = (@right_window.index == 2)
	@item_window4.visible = (@right_window.index == 3)
	@item_window5.visible = (@right_window.index == 4)
	# Get currently equipped item
	item1 = @right_window.item
	# Set current item window to @item_window
	case @right_window.index
	when 0
  	@item_window = @item_window1
	when 1
  	@item_window = @item_window2
	when 2
  	@item_window = @item_window3
	when 3
  	@item_window = @item_window4
	when 4
  	@item_window = @item_window5
	end
	# If right window is active
	if @right_window.active
  	# Erase parameters for after equipment change
  	@left_window.set_new_parameters(nil, nil, nil)
	end
	# If item window is active
	if @item_window.active
  	# Get currently selected item
  	item2 = @item_window.item
  	# Change equipment
  	last_hp = @actor.hp
  	last_sp = @actor.sp
  	@actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
  	# Get parameters for after equipment change
  	new_atk = @actor.atk
  	new_pdef = @actor.pdef
  	new_mdef = @actor.mdef
  	# Return equipment
  	@actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
  	@actor.hp = last_hp
  	@actor.sp = last_sp
  	# Draw in left window
  	@left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@left_window.update
	@right_window.update
	@item_window.update
	refresh
	# If right window is active: call update_right
	if @right_window.active
  	update_right
  	return
	end
	# If item window is active: call update_item
	if @item_window.active
  	update_item
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when right window is active)
  #--------------------------------------------------------------------------
  def update_right
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(2)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If equipment is fixed
  	if @actor.equip_fix?(@right_window.index)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# Activate item window
  	@right_window.active = false
  	@item_window.active = true
  	@item_window.index = 0
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different equipment screen
  	$scene = Scene_Equip.new(@actor_index, @right_window.index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different equipment screen
  	$scene = Scene_Equip.new(@actor_index, @right_window.index)
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Activate right window
  	@right_window.active = true
  	@item_window.active = false
  	@item_window.index = -1
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Play equip SE
  	$game_system.se_play($data_system.equip_se)
  	# Get currently selected data on the item window
  	item = @item_window.item
  	# Change equipment
  	@actor.equip(@right_window.index, item == nil ? 0 : item.id)
  	# Activate right window
  	@right_window.active = true
  	@item_window.active = false
  	@item_window.index = -1
  	# Remake right window and item window contents
  	@right_window.refresh
  	@item_window.refresh
  	return
	end
  end
end
#------------------------------------------------------------------------------
#  This class performs status screen processing.
#==============================================================================
 
class Scene_Status
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make status window
	@status_window = Window_Status.new(@actor)
	@status_window.opacity = 160  
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(3)
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different status screen
  	$scene = Scene_Status.new(@actor_index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different status screen
  	$scene = Scene_Status.new(@actor_index)
  	return
	end
  end
end
#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
#  This class performs game end screen processing.
#==============================================================================
 
class Scene_End
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Make command window
	s1 = "To Title"
	s2 = "Shutdown"
	s3 = "Cancel"
	@command_window = Window_Command.new(192, [s1, s2, s3])
	@command_window.opacity = 160
	@command_window.x = 320 - @command_window.width / 2
	@command_window.y = 240 - @command_window.height / 2
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame Update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of window
	@command_window.dispose
	# If switching to title screen
	if $scene.is_a?(Scene_Title)
  	# Fade out screen
  	Graphics.transition
  	Graphics.freeze
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update command window
	@command_window.update
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(5)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Branch by command window cursor position
  	case @command_window.index
  	when 0  # to title
    	command_to_title
  	when 1  # shutdown
    	command_shutdown
  	when 2  # quit
    	command_cancel
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [To Title] Command
  #--------------------------------------------------------------------------
  def command_to_title
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Fade out BGM, BGS, and ME
	Audio.bgm_fade(800)
	Audio.bgs_fade(800)
	Audio.me_fade(800)
	# Switch to title screen
	$scene = Scene_Title.new
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [Shutdown] Command
  #--------------------------------------------------------------------------
  def command_shutdown
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Fade out BGM, BGS, and ME
	Audio.bgm_fade(800)
	Audio.bgs_fade(800)
	Audio.me_fade(800)
	# Shutdown
	$scene = nil
  end
  #--------------------------------------------------------------------------
  # *  Process When Choosing [Cancel] Command
  #--------------------------------------------------------------------------
  def command_cancel
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Switch to menu screen
	$scene = Scene_Menu.new(5)
  end
end

zum Lesen den Text mit der Maus markieren

MFG

Realität ist auch nur eine Art von Rollenspiel.

Parzival

Ankömmling

Samstag, 23. April 2011, 16:28

Funktioniert super :yahoo!:

Danke

Asandril

Landsknecht

Sonntag, 24. April 2011, 01:06

In meiner vorherigen Post habe ich ein Fehler im Script gehabt.Nach kurzer Zeit verschwindet die Transparenz im Menü wieder.(Playm hat mich darauf aufmerksam gemacht).
Ich habe jetzt nochmal das Script verändert.Sollte noch ein Fehler auftreten, sofort bescheid sagen.

Spoiler

Ruby Quellcode

#==============================================================================
# ** Scene_Menu Transparent
#------------------------------------------------------------------------------
#  This class performs menu screen processing.
#==============================================================================
class Scene_Menu 
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
	@menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
 	@spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
 	# Make command window
	s1 = $data_system.words.item
	s2 = $data_system.words.skill
	s3 = $data_system.words.equip
	s4 = "Status"
	s5 = "Save"
	s6 = "End Game"
	@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
	@command_window.back_opacity = 160
	@command_window.index = @menu_index
	# If number of party members is 0
	if $game_party.actors.size == 0
  	# Disable items, skills, equipment, and status
  	@command_window.disable_item(0)
  	@command_window.disable_item(1)
  	@command_window.disable_item(2)
  	@command_window.disable_item(3)
	end
	# If save is forbidden
	if $game_system.save_disabled
  	# Disable save
  	@command_window.disable_item(4)
	end
	# Make play time window
	@playtime_window = Window_PlayTime.new
	@playtime_window.opacity = 160   
	@playtime_window.x = 0
	@playtime_window.y = 224
	# Make steps window
	@steps_window = Window_Steps.new
	@steps_window.opacity = 160   
	@steps_window.x = 0
	@steps_window.y = 320
	# Make gold window
	@gold_window = Window_Gold.new
	@gold_window.opacity = 160   
	@gold_window.x = 0
	@gold_window.y = 416
	# Make status window
	@status_window = Window_MenuStatus.new
	@status_window.opacity = 160  
	@status_window.x = 160
	@status_window.y = 0
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@command_window.dispose
	@playtime_window.dispose
	@steps_window.dispose
	@gold_window.dispose
	@status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@command_window.update
	@playtime_window.update
	@steps_window.update
	@gold_window.update
	@status_window.update
	# If command window is active: call update_command
	if @command_window.active
  	update_command
  	return
	end
	# If status window is active: call update_status
	if @status_window.active
  	update_status
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to map screen
  	$scene = Scene_Map.new
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If command other than save or end game, and party members = 0
  	if $game_party.actors.size == 0 and @command_window.index < 4
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Branch by command window cursor position
  	case @command_window.index
  	when 0  # item
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to item screen
    	$scene = Scene_Item.new
  	when 1  # skill
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Make status window active
    	@command_window.active = false
    	@status_window.active = true
    	@status_window.index = 0
  	when 2  # equipment
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Make status window active
    	@command_window.active = false
    	@status_window.active = true
    	@status_window.index = 0
  	when 3  # status
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Make status window active
    	@command_window.active = false
    	@status_window.active = true
    	@status_window.index = 0
  	when 4  # save
    	# If saving is forbidden
    	if $game_system.save_disabled
      	# Play buzzer SE
      	$game_system.se_play($data_system.buzzer_se)
      	return
    	end
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to save screen
    	$scene = Scene_Save.new
  	when 5  # end game
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to end game screen
    	$scene = Scene_End.new
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when status window is active)
  #--------------------------------------------------------------------------
  def update_status
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Make command window active
  	@command_window.active = true
  	@status_window.active = false
  	@status_window.index = -1
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Branch by command window cursor position
  	case @command_window.index
  	when 1  # skill
    	# If this actor's action limit is 2 or more
    	if $game_party.actors[@status_window.index].restriction >= 2
      	# Play buzzer SE
      	$game_system.se_play($data_system.buzzer_se)
      	return
    	end
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to skill screen
    	$scene = Scene_Skill.new(@status_window.index)
  	when 2  # equipment
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to equipment screen
    	$scene = Scene_Equip.new(@status_window.index)
  	when 3  # status
    	# Play decision SE
    	$game_system.se_play($data_system.decision_se)
    	# Switch to status screen
    	$scene = Scene_Status.new(@status_window.index)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Item
#------------------------------------------------------------------------------
#  This class performs item screen processing.
#==============================================================================
 
class Scene_Item
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Make help window, item window
	@help_window = Window_Help.new
	@item_window = Window_Item.new
	@help_window.opacity = 160  
	@item_window.opacity = 160  
	# Associate help window
	@item_window.help_window = @help_window
	# Make target window (set to invisible / inactive)
	@target_window = Window_Target.new
	@target_window.visible = false
	@target_window.active = false
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@item_window.dispose
	@target_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@help_window.update
	@item_window.update
	@target_window.update
	# If item window is active: call update_item
	if @item_window.active
  	update_item
  	return
	end
	# If target window is active: call update_target
	if @target_window.active
  	update_target
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(0)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Get currently selected data on the item window
  	@item = @item_window.item
  	# If not a use item
  	unless @item.is_a?(RPG::Item)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# If it can't be used
  	unless $game_party.item_can_use?(@item.id)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# If effect scope is an ally
  	if @item.scope >= 3
    	# Activate target window
    	@item_window.active = false
    	@target_window.x = (@item_window.index + 1) % 2 * 304
    	@target_window.visible = true
    	@target_window.active = true
    	# Set cursor position to effect scope (single / all)
    	if @item.scope == 4 || @item.scope == 6
      	@target_window.index = -1
    	else
      	@target_window.index = 0
    	end
  	# If effect scope is other than an ally
  	else
    	# If command event ID is valid
    	if @item.common_event_id > 0
      	# Command event call reservation
      	$game_temp.common_event_id = @item.common_event_id
      	# Play item use SE
      	$game_system.se_play(@item.menu_se)
      	# If consumable
      	if @item.consumable
        	# Decrease used items by 1
        	$game_party.lose_item(@item.id, 1)
        	# Draw item window item
        	@item_window.draw_item(@item_window.index)
      	end
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# If unable to use because items ran out
  	unless $game_party.item_can_use?(@item.id)
    	# Remake item window contents
    	@item_window.refresh
  	end
  	# Erase target window
  	@item_window.active = true
  	@target_window.visible = false
  	@target_window.active = false
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If items are used up
  	if $game_party.item_number(@item.id) == 0
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# If target is all
  	if @target_window.index == -1
    	# Apply item effects to entire party
    	used = false
    	for i in $game_party.actors
      	used |= i.item_effect(@item)
    	end
  	end
  	# If single target
  	if @target_window.index >= 0
    	# Apply item use effects to target actor
    	target = $game_party.actors[@target_window.index]
    	used = target.item_effect(@item)
  	end
  	# If an item was used
  	if used
    	# Play item use SE
    	$game_system.se_play(@item.menu_se)
    	# If consumable
    	if @item.consumable
      	# Decrease used items by 1
      	$game_party.lose_item(@item.id, 1)
      	# Redraw item window item
      	@item_window.draw_item(@item_window.index)
    	end
    	# Remake target window contents
    	@target_window.refresh
    	# If all party members are dead
    	if $game_party.all_dead?
      	# Switch to game over screen
      	$scene = Scene_Gameover.new
      	return
    	end
    	# If common event ID is valid
    	if @item.common_event_id > 0
      	# Common event call reservation
      	$game_temp.common_event_id = @item.common_event_id
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	# If item wasn't used
  	unless used
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Skill
#------------------------------------------------------------------------------
#  This class performs skill screen processing.
#==============================================================================
 
class Scene_Skill
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make help window, status window, and skill window
	@help_window = Window_Help.new
	@help_window.opacity = 160  
	@status_window = Window_SkillStatus.new(@actor)
	@status_window.opacity = 160  
	@skill_window = Window_Skill.new(@actor)
	@skill_window.opacity = 160  
	# Associate help window
	@skill_window.help_window = @help_window
	# Make target window (set to invisible / inactive)
	@target_window = Window_Target.new
	@target_window.visible = false
	@target_window.active = false
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@status_window.dispose
	@skill_window.dispose
	@target_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@help_window.update
	@status_window.update
	@skill_window.update
	@target_window.update
	# If skill window is active: call update_skill
	if @skill_window.active
  	update_skill
  	return
	end
	# If skill target is active: call update_target
	if @target_window.active
  	update_target
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if skill window is active)
  #--------------------------------------------------------------------------
  def update_skill
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(1)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Get currently selected data on the skill window
  	@skill = @skill_window.skill
  	# If unable to use
  	if @skill == nil or not @actor.skill_can_use?(@skill.id)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# If effect scope is ally
  	if @skill.scope >= 3
    	# Activate target window
    	@skill_window.active = false
    	@target_window.x = (@skill_window.index + 1) % 2 * 304
    	@target_window.visible = true
    	@target_window.active = true
    	# Set cursor position to effect scope (single / all)
    	if @skill.scope == 4 || @skill.scope == 6
      	@target_window.index = -1
    	elsif @skill.scope == 7
      	@target_window.index = @actor_index - 10
    	else
      	@target_window.index = 0
    	end
  	# If effect scope is other than ally
  	else
    	# If common event ID is valid
    	if @skill.common_event_id > 0
      	# Common event call reservation
      	$game_temp.common_event_id = @skill.common_event_id
      	# Play use skill SE
      	$game_system.se_play(@skill.menu_se)
      	# Use up SP
      	@actor.sp -= @skill.sp_cost
      	# Remake each window content
      	@status_window.refresh
      	@skill_window.refresh
      	@target_window.refresh
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different skill screen
  	$scene = Scene_Skill.new(@actor_index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different skill screen
  	$scene = Scene_Skill.new(@actor_index)
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Erase target window
  	@skill_window.active = true
  	@target_window.visible = false
  	@target_window.active = false
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If unable to use because SP ran out
  	unless @actor.skill_can_use?(@skill.id)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# If target is all
  	if @target_window.index == -1
    	# Apply skill use effects to entire party
    	used = false
    	for i in $game_party.actors
      	used |= i.skill_effect(@actor, @skill)
    	end
  	end
  	# If target is user
  	if @target_window.index <= -2
    	# Apply skill use effects to target actor
    	target = $game_party.actors[@target_window.index + 10]
    	used = target.skill_effect(@actor, @skill)
  	end
  	# If single target
  	if @target_window.index >= 0
    	# Apply skill use effects to target actor
    	target = $game_party.actors[@target_window.index]
    	used = target.skill_effect(@actor, @skill)
  	end
  	# If skill was used
  	if used
    	# Play skill use SE
    	$game_system.se_play(@skill.menu_se)
    	# Use up SP
    	@actor.sp -= @skill.sp_cost
    	# Remake each window content
    	@status_window.refresh
    	@skill_window.refresh
    	@target_window.refresh
    	# If entire party is dead
    	if $game_party.all_dead?
      	# Switch to game over screen
      	$scene = Scene_Gameover.new
      	return
    	end
    	# If command event ID is valid
    	if @skill.common_event_id > 0
      	# Command event call reservation
      	$game_temp.common_event_id = @skill.common_event_id
      	# Switch to map screen
      	$scene = Scene_Map.new
      	return
    	end
  	end
  	# If skill wasn't used
  	unless used
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Equip
#------------------------------------------------------------------------------
#  This class performs equipment screen processing.
#==============================================================================
 
class Scene_Equip
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  # 	equip_index : equipment index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
	@equip_index = equip_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make windows
	@help_window = Window_Help.new
	@help_window.opacity = 160  
	@left_window = Window_EquipLeft.new(@actor)
	@left_window.opacity = 160  
	@right_window = Window_EquipRight.new(@actor)
	@right_window.opacity = 160  
	@item_window1 = Window_EquipItem.new(@actor, 0)
	@item_window1.opacity = 160  
	@item_window2 = Window_EquipItem.new(@actor, 1)
	@item_window2.opacity = 160  
	@item_window3 = Window_EquipItem.new(@actor, 2)
	@item_window3.opacity = 160  
	@item_window4 = Window_EquipItem.new(@actor, 3)
	@item_window4.opacity = 160  
	@item_window5 = Window_EquipItem.new(@actor, 4)
	@item_window5.opacity = 160  
	# Associate help window
	@right_window.help_window = @help_window
	@item_window1.help_window = @help_window
	@item_window2.help_window = @help_window
	@item_window3.help_window = @help_window
	@item_window4.help_window = @help_window
	@item_window5.help_window = @help_window
	# Set cursor position
	@right_window.index = @equip_index
	refresh
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@left_window.dispose
	@right_window.dispose
	@item_window1.dispose
	@item_window2.dispose
	@item_window3.dispose
	@item_window4.dispose
	@item_window5.dispose
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
	# Set item window to visible
	@item_window1.visible = (@right_window.index == 0)
	@item_window2.visible = (@right_window.index == 1)
	@item_window3.visible = (@right_window.index == 2)
	@item_window4.visible = (@right_window.index == 3)
	@item_window5.visible = (@right_window.index == 4)
	# Get currently equipped item
	item1 = @right_window.item
	# Set current item window to @item_window
	case @right_window.index
	when 0
  	@item_window = @item_window1
	when 1
  	@item_window = @item_window2
	when 2
  	@item_window = @item_window3
	when 3
  	@item_window = @item_window4
	when 4
  	@item_window = @item_window5
	end
	# If right window is active
	if @right_window.active
  	# Erase parameters for after equipment change
  	@left_window.set_new_parameters(nil, nil, nil)
	end
	# If item window is active
	if @item_window.active
  	# Get currently selected item
  	item2 = @item_window.item
  	# Change equipment
  	last_hp = @actor.hp
  	last_sp = @actor.sp
  	@actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
  	# Get parameters for after equipment change
  	new_atk = @actor.atk
  	new_pdef = @actor.pdef
  	new_mdef = @actor.mdef
  	# Return equipment
  	@actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
  	@actor.hp = last_hp
  	@actor.sp = last_sp
  	# Draw in left window
  	@left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@left_window.update
	@right_window.update
	@item_window.update
	refresh
	# If right window is active: call update_right
	if @right_window.active
  	update_right
  	return
	end
	# If item window is active: call update_item
	if @item_window.active
  	update_item
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when right window is active)
  #--------------------------------------------------------------------------
  def update_right
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(2)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If equipment is fixed
  	if @actor.equip_fix?(@right_window.index)
    	# Play buzzer SE
    	$game_system.se_play($data_system.buzzer_se)
    	return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# Activate item window
  	@right_window.active = false
  	@item_window.active = true
  	@item_window.index = 0
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different equipment screen
  	$scene = Scene_Equip.new(@actor_index, @right_window.index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different equipment screen
  	$scene = Scene_Equip.new(@actor_index, @right_window.index)
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Activate right window
  	@right_window.active = true
  	@item_window.active = false
  	@item_window.index = -1
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Play equip SE
  	$game_system.se_play($data_system.equip_se)
  	# Get currently selected data on the item window
  	item = @item_window.item
  	# Change equipment
  	@actor.equip(@right_window.index, item == nil ? 0 : item.id)
  	# Activate right window
  	@right_window.active = true
  	@item_window.active = false
  	@item_window.index = -1
  	# Remake right window and item window contents
  	@right_window.refresh
  	@item_window.refresh
  	return
	end
  end
end
#------------------------------------------------------------------------------
#  This class performs status screen processing.
#==============================================================================
 
class Scene_Status
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make status window
	@status_window = Window_Status.new(@actor)
	@status_window.opacity = 160  
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@status_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(3)
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different status screen
  	$scene = Scene_Status.new(@actor_index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different status screen
  	$scene = Scene_Status.new(@actor_index)
  	return
	end
  end
end
#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
#  This class performs game end screen processing.
#==============================================================================
 
class Scene_End
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	# Make command window
	s1 = "To Title"
	s2 = "Shutdown"
	s3 = "Cancel"
	@command_window = Window_Command.new(192, [s1, s2, s3])
	@command_window.opacity = 160
	@command_window.x = 320 - @command_window.width / 2
	@command_window.y = 240 - @command_window.height / 2
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame Update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
    	break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of window
	@command_window.dispose
	# If switching to title screen
	if $scene.is_a?(Scene_Title)
  	# Fade out screen
  	Graphics.transition
  	Graphics.freeze
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update command window
	@command_window.update
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(5)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Branch by command window cursor position
  	case @command_window.index
  	when 0  # to title
    	command_to_title
  	when 1  # shutdown
    	command_shutdown
  	when 2  # quit
    	command_cancel
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [To Title] Command
  #--------------------------------------------------------------------------
  def command_to_title
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Fade out BGM, BGS, and ME
	Audio.bgm_fade(800)
	Audio.bgs_fade(800)
	Audio.me_fade(800)
	# Switch to title screen
	$scene = Scene_Title.new
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [Shutdown] Command
  #--------------------------------------------------------------------------
  def command_shutdown
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Fade out BGM, BGS, and ME
	Audio.bgm_fade(800)
	Audio.bgs_fade(800)
	Audio.me_fade(800)
	# Shutdown
	$scene = nil
  end
  #--------------------------------------------------------------------------
  # *  Process When Choosing [Cancel] Command
  #--------------------------------------------------------------------------
  def command_cancel
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Switch to menu screen
	$scene = Scene_Menu.new(5)
  end
end

zum Lesen den Text mit der Maus markieren

MFG

Realität ist auch nur eine Art von Rollenspiel.

Parzival

Ankömmling

Donnerstag, 28. April 2011, 18:11

Mir ist aufgefallen, dass das Skript nicht kompatibel ist mit dem Location Script von Moghunter. Wäre echt toll wenn du auch eine Lösung dafür hättest, ansonsten müsste ich das Skript von Moghunter nähmlich ausbauen.

MfG

Asandril

Landsknecht

Donnerstag, 28. April 2011, 20:07

OK.Mit dieser Änderung sollte es jetzt klappen.
Schmeiß das Alte Tranparent-Script raus und ersätze es mit diesem.

<Script gelöscht>

EDIT : So nach einigen schwierigkeiten habe ich das Script jetzt so verändert, dass es nicht mehr abstürzen sollte.

Script:

Spoiler

Ruby Quellcode

#==============================================================================
# ** Scene_Menu Transparent
#------------------------------------------------------------------------------
#  This class performs menu screen processing.
#==============================================================================
class Scene_Menu 
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	menu_index : command cursor's initial position
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
	@menu_index = menu_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
  @spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
 	# Make command window
	s1 = $data_system.words.item
	s2 = $data_system.words.skill
	s3 = $data_system.words.equip
	s4 = "Status"
	s5 = "Save"
	s6 = "End Game"
	@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])
	@command_window.back_opacity = 160
	@command_window.index = @menu_index
	# If number of party members is 0
	if $game_party.actors.size == 0
  	# Disable items, skills, equipment, and status
  	@command_window.disable_item(0)
  	@command_window.disable_item(1)
  	@command_window.disable_item(2)
  	@command_window.disable_item(3)
	end
	# If save is forbidden
	if $game_system.save_disabled
  	# Disable save
  	@command_window.disable_item(4)
	end
	# Make play time window
	@playtime_window = Window_PlayTime.new
	@playtime_window.opacity = 160   
	@playtime_window.x = 0
	@playtime_window.y = 224
	# Make steps window
	@steps_window = Window_Steps.new
	@steps_window.opacity = 160   
	@steps_window.x = 0
	@steps_window.y = 320
	# Make gold window
	@gold_window = Window_Gold.new
	@gold_window.opacity = 160   
	@gold_window.x = 0
	@gold_window.y = 416
	# Make status window
	@status_window = Window_MenuStatus.new
	@status_window.opacity = 160  
	@status_window.x = 160
	@status_window.y = 0
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
		break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@command_window.dispose
	@playtime_window.dispose
	@steps_window.dispose
	@gold_window.dispose
	@status_window.dispose
  @spriteset.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@command_window.update
	@playtime_window.update
	@steps_window.update
	@gold_window.update
	@status_window.update
  # If command window is active: call update_command
	if @command_window.active
  	update_command
  	return
	end
	# If status window is active: call update_status
	if @status_window.active
  	update_status
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to map screen
  	$scene = Scene_Map.new
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If command other than save or end game, and party members = 0
  	if $game_party.actors.size == 0 and @command_window.index < 4
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# Branch by command window cursor position
  	case @command_window.index
  	when 0  # item
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Switch to item screen
		$scene = Scene_Item.new
  	when 1  # skill
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Make status window active
		@command_window.active = false
		@status_window.active = true
		@status_window.index = 0
  	when 2  # equipment
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Make status window active
		@command_window.active = false
		@status_window.active = true
		@status_window.index = 0
  	when 3  # status
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Make status window active
		@command_window.active = false
		@status_window.active = true
		@status_window.index = 0
  	when 4  # save
		# If saving is forbidden
		if $game_system.save_disabled
  		# Play buzzer SE
  		$game_system.se_play($data_system.buzzer_se)
  		return
		end
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Switch to save screen
		$scene = Scene_Save.new
  	when 5  # end game
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Switch to end game screen
		$scene = Scene_End.new
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when status window is active)
  #--------------------------------------------------------------------------
  def update_status
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Make command window active
  	@command_window.active = true
  	@status_window.active = false
  	@status_window.index = -1
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Branch by command window cursor position
  	case @command_window.index
  	when 1  # skill
		# If this actor's action limit is 2 or more
		if $game_party.actors[@status_window.index].restriction >= 2
  		# Play buzzer SE
  		$game_system.se_play($data_system.buzzer_se)
  		return
		end
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Switch to skill screen
		$scene = Scene_Skill.new(@status_window.index)
  	when 2  # equipment
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Switch to equipment screen
		$scene = Scene_Equip.new(@status_window.index)
  	when 3  # status
		# Play decision SE
		$game_system.se_play($data_system.decision_se)
		# Switch to status screen
		$scene = Scene_Status.new(@status_window.index)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Item
#------------------------------------------------------------------------------
#  This class performs item screen processing.
#==============================================================================
 
class Scene_Item
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	@spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
	# Make help window, item window
	@help_window = Window_Help.new
	@item_window = Window_Item.new
	@help_window.opacity = 160  
	@item_window.opacity = 160  
	# Associate help window
	@item_window.help_window = @help_window
	# Make target window (set to invisible / inactive)
	@target_window = Window_Target.new
	@target_window.visible = false
	@target_window.active = false
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
		break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@item_window.dispose
	@target_window.dispose
   @spriteset.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@help_window.update
	@item_window.update
	@target_window.update
	# If item window is active: call update_item
	if @item_window.active
  	update_item
  	return
	end
	# If target window is active: call update_target
	if @target_window.active
  	update_target
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(0)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Get currently selected data on the item window
  	@item = @item_window.item
  	# If not a use item
  	unless @item.is_a?(RPG::Item)
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# If it can't be used
  	unless $game_party.item_can_use?(@item.id)
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# If effect scope is an ally
  	if @item.scope >= 3
		# Activate target window
		@item_window.active = false
		@target_window.x = (@item_window.index + 1) % 2 * 304
		@target_window.visible = true
		@target_window.active = true
		# Set cursor position to effect scope (single / all)
		if @item.scope == 4 || @item.scope == 6
  		@target_window.index = -1
		else
  		@target_window.index = 0
		end
  	# If effect scope is other than an ally
  	else
		# If command event ID is valid
		if @item.common_event_id > 0
  		# Command event call reservation
  		$game_temp.common_event_id = @item.common_event_id
  		# Play item use SE
  		$game_system.se_play(@item.menu_se)
  		# If consumable
  		if @item.consumable
			# Decrease used items by 1
			$game_party.lose_item(@item.id, 1)
			# Draw item window item
			@item_window.draw_item(@item_window.index)
  		end
  		# Switch to map screen
  		$scene = Scene_Map.new
  		return
		end
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# If unable to use because items ran out
  	unless $game_party.item_can_use?(@item.id)
		# Remake item window contents
		@item_window.refresh
  	end
  	# Erase target window
  	@item_window.active = true
  	@target_window.visible = false
  	@target_window.active = false
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If items are used up
  	if $game_party.item_number(@item.id) == 0
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# If target is all
  	if @target_window.index == -1
		# Apply item effects to entire party
		used = false
		for i in $game_party.actors
  		used |= i.item_effect(@item)
		end
  	end
  	# If single target
  	if @target_window.index >= 0
		# Apply item use effects to target actor
		target = $game_party.actors[@target_window.index]
		used = target.item_effect(@item)
  	end
  	# If an item was used
  	if used
		# Play item use SE
		$game_system.se_play(@item.menu_se)
		# If consumable
		if @item.consumable
  		# Decrease used items by 1
  		$game_party.lose_item(@item.id, 1)
  		# Redraw item window item
  		@item_window.draw_item(@item_window.index)
		end
		# Remake target window contents
		@target_window.refresh
		# If all party members are dead
		if $game_party.all_dead?
  		# Switch to game over screen
  		$scene = Scene_Gameover.new
  		return
		end
		# If common event ID is valid
		if @item.common_event_id > 0
  		# Common event call reservation
  		$game_temp.common_event_id = @item.common_event_id
  		# Switch to map screen
  		$scene = Scene_Map.new
  		return
		end
  	end
  	# If item wasn't used
  	unless used
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Skill
#------------------------------------------------------------------------------
#  This class performs skill screen processing.
#==============================================================================
 
class Scene_Skill
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
  @spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end  
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make help window, status window, and skill window
	@help_window = Window_Help.new
	@help_window.opacity = 160  
	@status_window = Window_SkillStatus.new(@actor)
	@status_window.opacity = 160  
	@skill_window = Window_Skill.new(@actor)
	@skill_window.opacity = 160  
	# Associate help window
	@skill_window.help_window = @help_window
	# Make target window (set to invisible / inactive)
	@target_window = Window_Target.new
	@target_window.visible = false
	@target_window.active = false
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
		break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@status_window.dispose
	@skill_window.dispose
	@target_window.dispose
   @spriteset.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@help_window.update
	@status_window.update
	@skill_window.update
	@target_window.update
	# If skill window is active: call update_skill
	if @skill_window.active
  	update_skill
  	return
	end
	# If skill target is active: call update_target
	if @target_window.active
  	update_target
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (if skill window is active)
  #--------------------------------------------------------------------------
  def update_skill
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(1)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Get currently selected data on the skill window
  	@skill = @skill_window.skill
  	# If unable to use
  	if @skill == nil or not @actor.skill_can_use?(@skill.id)
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# If effect scope is ally
  	if @skill.scope >= 3
		# Activate target window
		@skill_window.active = false
		@target_window.x = (@skill_window.index + 1) % 2 * 304
		@target_window.visible = true
		@target_window.active = true
		# Set cursor position to effect scope (single / all)
		if @skill.scope == 4 || @skill.scope == 6
  		@target_window.index = -1
		elsif @skill.scope == 7
  		@target_window.index = @actor_index - 10
		else
  		@target_window.index = 0
		end
  	# If effect scope is other than ally
  	else
		# If common event ID is valid
		if @skill.common_event_id > 0
  		# Common event call reservation
  		$game_temp.common_event_id = @skill.common_event_id
  		# Play use skill SE
  		$game_system.se_play(@skill.menu_se)
  		# Use up SP
  		@actor.sp -= @skill.sp_cost
  		# Remake each window content
  		@status_window.refresh
  		@skill_window.refresh
  		@target_window.refresh
  		# Switch to map screen
  		$scene = Scene_Map.new
  		return
		end
  	end
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different skill screen
  	$scene = Scene_Skill.new(@actor_index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different skill screen
  	$scene = Scene_Skill.new(@actor_index)
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when target window is active)
  #--------------------------------------------------------------------------
  def update_target
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Erase target window
  	@skill_window.active = true
  	@target_window.visible = false
  	@target_window.active = false
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If unable to use because SP ran out
  	unless @actor.skill_can_use?(@skill.id)
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# If target is all
  	if @target_window.index == -1
		# Apply skill use effects to entire party
		used = false
		for i in $game_party.actors
  		used |= i.skill_effect(@actor, @skill)
		end
  	end
  	# If target is user
  	if @target_window.index <= -2
		# Apply skill use effects to target actor
		target = $game_party.actors[@target_window.index + 10]
		used = target.skill_effect(@actor, @skill)
  	end
  	# If single target
  	if @target_window.index >= 0
		# Apply skill use effects to target actor
		target = $game_party.actors[@target_window.index]
		used = target.skill_effect(@actor, @skill)
  	end
  	# If skill was used
  	if used
		# Play skill use SE
		$game_system.se_play(@skill.menu_se)
		# Use up SP
		@actor.sp -= @skill.sp_cost
		# Remake each window content
		@status_window.refresh
		@skill_window.refresh
		@target_window.refresh
		# If entire party is dead
		if $game_party.all_dead?
  		# Switch to game over screen
  		$scene = Scene_Gameover.new
  		return
		end
		# If command event ID is valid
		if @skill.common_event_id > 0
  		# Command event call reservation
  		$game_temp.common_event_id = @skill.common_event_id
  		# Switch to map screen
  		$scene = Scene_Map.new
  		return
		end
  	end
  	# If skill wasn't used
  	unless used
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
  	end
  	return
	end
  end
end
#==============================================================================
# ** Scene_Equip
#------------------------------------------------------------------------------
#  This class performs equipment screen processing.
#==============================================================================
 
class Scene_Equip
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  # 	equip_index : equipment index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
	@equip_index = equip_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	@spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make windows
	@help_window = Window_Help.new
	@help_window.opacity = 160  
	@left_window = Window_EquipLeft.new(@actor)
	@left_window.opacity = 160  
	@right_window = Window_EquipRight.new(@actor)
	@right_window.opacity = 160  
	@item_window1 = Window_EquipItem.new(@actor, 0)
	@item_window1.opacity = 160  
	@item_window2 = Window_EquipItem.new(@actor, 1)
	@item_window2.opacity = 160  
	@item_window3 = Window_EquipItem.new(@actor, 2)
	@item_window3.opacity = 160  
	@item_window4 = Window_EquipItem.new(@actor, 3)
	@item_window4.opacity = 160  
	@item_window5 = Window_EquipItem.new(@actor, 4)
	@item_window5.opacity = 160  
	# Associate help window
	@right_window.help_window = @help_window
	@item_window1.help_window = @help_window
	@item_window2.help_window = @help_window
	@item_window3.help_window = @help_window
	@item_window4.help_window = @help_window
	@item_window5.help_window = @help_window
	# Set cursor position
	@right_window.index = @equip_index
	refresh
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
		break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@help_window.dispose
	@left_window.dispose
	@right_window.dispose
	@item_window1.dispose
	@item_window2.dispose
	@item_window3.dispose
	@item_window4.dispose
	@item_window5.dispose
   @spriteset.dispose
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
	# Set item window to visible
	@item_window1.visible = (@right_window.index == 0)
	@item_window2.visible = (@right_window.index == 1)
	@item_window3.visible = (@right_window.index == 2)
	@item_window4.visible = (@right_window.index == 3)
	@item_window5.visible = (@right_window.index == 4)
	# Get currently equipped item
	item1 = @right_window.item
	# Set current item window to @item_window
	case @right_window.index
	when 0
  	@item_window = @item_window1
	when 1
  	@item_window = @item_window2
	when 2
  	@item_window = @item_window3
	when 3
  	@item_window = @item_window4
	when 4
  	@item_window = @item_window5
	end
	# If right window is active
	if @right_window.active
  	# Erase parameters for after equipment change
  	@left_window.set_new_parameters(nil, nil, nil)
	end
	# If item window is active
	if @item_window.active
  	# Get currently selected item
  	item2 = @item_window.item
  	# Change equipment
  	last_hp = @actor.hp
  	last_sp = @actor.sp
  	@actor.equip(@right_window.index, item2 == nil ? 0 : item2.id)
  	# Get parameters for after equipment change
  	new_atk = @actor.atk
  	new_pdef = @actor.pdef
  	new_mdef = @actor.mdef
  	# Return equipment
  	@actor.equip(@right_window.index, item1 == nil ? 0 : item1.id)
  	@actor.hp = last_hp
  	@actor.sp = last_sp
  	# Draw in left window
  	@left_window.set_new_parameters(new_atk, new_pdef, new_mdef)
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update windows
	@left_window.update
	@right_window.update
	@item_window.update
	refresh
	# If right window is active: call update_right
	if @right_window.active
  	update_right
  	return
	end
	# If item window is active: call update_item
	if @item_window.active
  	update_item
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when right window is active)
  #--------------------------------------------------------------------------
  def update_right
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(2)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# If equipment is fixed
  	if @actor.equip_fix?(@right_window.index)
		# Play buzzer SE
		$game_system.se_play($data_system.buzzer_se)
		return
  	end
  	# Play decision SE
  	$game_system.se_play($data_system.decision_se)
  	# Activate item window
  	@right_window.active = false
  	@item_window.active = true
  	@item_window.index = 0
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different equipment screen
  	$scene = Scene_Equip.new(@actor_index, @right_window.index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different equipment screen
  	$scene = Scene_Equip.new(@actor_index, @right_window.index)
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (when item window is active)
  #--------------------------------------------------------------------------
  def update_item
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Activate right window
  	@right_window.active = true
  	@item_window.active = false
  	@item_window.index = -1
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Play equip SE
  	$game_system.se_play($data_system.equip_se)
  	# Get currently selected data on the item window
  	item = @item_window.item
  	# Change equipment
  	@actor.equip(@right_window.index, item == nil ? 0 : item.id)
  	# Activate right window
  	@right_window.active = true
  	@item_window.active = false
  	@item_window.index = -1
  	# Remake right window and item window contents
  	@right_window.refresh
  	@item_window.refresh
  	return
	end
  end
end
#------------------------------------------------------------------------------
#  This class performs status screen processing.
#==============================================================================
 
class Scene_Status
  #--------------------------------------------------------------------------
  # * Object Initialization
  # 	actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, equip_index = 0)
	@actor_index = actor_index
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	@spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
	# Get actor
	@actor = $game_party.actors[@actor_index]
	# Make status window
	@status_window = Window_Status.new(@actor)
	@status_window.opacity = 160  
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
		break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of windows
	@status_window.dispose
   @spriteset.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(3)
  	return
	end
	# If R button was pressed
	if Input.trigger?(Input::R)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To next actor
  	@actor_index += 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different status screen
  	$scene = Scene_Status.new(@actor_index)
  	return
	end
	# If L button was pressed
	if Input.trigger?(Input::L)
  	# Play cursor SE
  	$game_system.se_play($data_system.cursor_se)
  	# To previous actor
  	@actor_index += $game_party.actors.size - 1
  	@actor_index %= $game_party.actors.size
  	# Switch to different status screen
  	$scene = Scene_Status.new(@actor_index)
  	return
	end
  end
end
#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
#  This class performs game end screen processing.
#==============================================================================
 
class Scene_End
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
	@spriteset = Spriteset_Map.new
	@message_window = Window_Message.new
  	Graphics.freeze
  	if $scene.is_a?(Scene_Title)
  	Graphics.transition
  	Graphics.freeze
	end
 	# Make command window
	s1 = "To Title"
	s2 = "Shutdown"
	s3 = "Cancel"
	@command_window = Window_Command.new(192, [s1, s2, s3])
	@command_window.opacity = 160
	@command_window.x = 320 - @command_window.width / 2
	@command_window.y = 240 - @command_window.height / 2
	# Execute transition
	Graphics.transition
	# Main loop
	loop do
  	# Update game screen
  	Graphics.update
  	# Update input information
  	Input.update
  	# Frame Update
  	update
  	# Abort loop if screen is changed
  	if $scene != self
		break
  	end
	end
	# Prepare for transition
	Graphics.freeze
	# Dispose of window
	@command_window.dispose
   @spriteset.dispose
	# If switching to title screen
	if $scene.is_a?(Scene_Title)
  	# Fade out screen
  	Graphics.transition
  	Graphics.freeze
	end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
	# Update command window
	@command_window.update
	# If B button was pressed
	if Input.trigger?(Input::B)
  	# Play cancel SE
  	$game_system.se_play($data_system.cancel_se)
  	# Switch to menu screen
  	$scene = Scene_Menu.new(5)
  	return
	end
	# If C button was pressed
	if Input.trigger?(Input::C)
  	# Branch by command window cursor position
  	case @command_window.index
  	when 0  # to title
		command_to_title
  	when 1  # shutdown
		command_shutdown
  	when 2  # quit
		command_cancel
  	end
  	return
	end
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [To Title] Command
  #--------------------------------------------------------------------------
  def command_to_title
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Fade out BGM, BGS, and ME
	Audio.bgm_fade(800)
	Audio.bgs_fade(800)
	Audio.me_fade(800)
	# Switch to title screen
	$scene = Scene_Title.new
  end
  #--------------------------------------------------------------------------
  # * Process When Choosing [Shutdown] Command
  #--------------------------------------------------------------------------
  def command_shutdown
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Fade out BGM, BGS, and ME
	Audio.bgm_fade(800)
	Audio.bgs_fade(800)
	Audio.me_fade(800)
	# Shutdown
	$scene = nil
  end
  #--------------------------------------------------------------------------
  # *  Process When Choosing [Cancel] Command
  #--------------------------------------------------------------------------
  def command_cancel
	# Play decision SE
	$game_system.se_play($data_system.decision_se)
	# Switch to menu screen
	$scene = Scene_Menu.new(5)
  end
end