mirror of
https://forgejo.xatacraft.ru/Sunshine/mkxp-sunshine.git
synced 2026-08-20 22:09:55 +00:00
removed some trash
This commit is contained in:
Issac332
parent
63b729fa5b
commit
6ba6b19db5
34 changed files with 1 additions and 3101 deletions
|
|
@ -19,7 +19,6 @@ set(scripts
|
|||
Game_Character_2.rb
|
||||
Game_Character_3.rb
|
||||
Game_CommonEvent.rb
|
||||
Game_Enemy.rb
|
||||
Game_Event.rb
|
||||
Game_FastTravel.rb
|
||||
Game_Follower.rb
|
||||
|
|
@ -51,20 +50,10 @@ set(scripts
|
|||
RPG.rb
|
||||
SaveLoad.rb
|
||||
Scene_Debug.rb
|
||||
Scene_End.rb
|
||||
Scene_Equip.rb
|
||||
Scene_File.rb
|
||||
Scene_Item.rb
|
||||
Scene_Load.rb
|
||||
Scene_Map.rb
|
||||
Scene_Menu.rb
|
||||
Scene_Name.rb
|
||||
Scene_Save.rb
|
||||
Scene_Skill.rb
|
||||
Scene_Status.rb
|
||||
Scene_Title.rb
|
||||
Script.rb
|
||||
Sprite_Battler.rb
|
||||
Sprite_Character.rb
|
||||
Sprite_Footprint.rb
|
||||
Sprite_Footsplash.rb
|
||||
|
|
@ -74,36 +63,17 @@ set(scripts
|
|||
Sprite_Timer.rb
|
||||
Spriteset_Map.rb
|
||||
Window_Base.rb
|
||||
Window_BattleResult.rb
|
||||
Window_BattleStatus.rb
|
||||
Window_Command.rb
|
||||
Window_DebugLeft.rb
|
||||
Window_DebugRight.rb
|
||||
Window_EquipItem.rb
|
||||
Window_EquipLeft.rb
|
||||
Window_EquipRight.rb
|
||||
Window_Gold.rb
|
||||
Window_Help.rb
|
||||
Window_InputNumber.rb
|
||||
Window_Item.rb
|
||||
Window_MainMenu.rb
|
||||
Window_MenuStatus.rb
|
||||
Window_Message.rb
|
||||
Window_NameEdit.rb
|
||||
Window_NameInput.rb
|
||||
Window_PartyCommand.rb
|
||||
Window_PlayTime.rb
|
||||
Window_SaveFile.rb
|
||||
Window_Selectable.rb
|
||||
Window_Settings.rb
|
||||
Window_ShopBuy.rb
|
||||
Window_ShopCommand.rb
|
||||
Window_ShopNumber.rb
|
||||
Window_ShopSell.rb
|
||||
Window_ShopStatus.rb
|
||||
Window_Status.rb
|
||||
Window_Steps.rb
|
||||
Window_Target.rb
|
||||
i18n_English.rb
|
||||
i18n_Japanese.rb
|
||||
i18n_Language.rb
|
||||
|
|
|
|||
|
|
@ -1,317 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Game_Enemy
|
||||
#------------------------------------------------------------------------------
|
||||
# This class handles enemies. It's used within the Game_Troop class
|
||||
# ($game_troop).
|
||||
#==============================================================================
|
||||
|
||||
class Game_Enemy < Game_Battler
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# troop_id : troop ID
|
||||
# member_index : troop member index
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(troop_id, member_index)
|
||||
super()
|
||||
@troop_id = troop_id
|
||||
@member_index = member_index
|
||||
troop = $data_troops[@troop_id]
|
||||
@enemy_id = troop.members[@member_index].enemy_id
|
||||
enemy = $data_enemies[@enemy_id]
|
||||
@battler_name = enemy.battler_name
|
||||
@battler_hue = enemy.battler_hue
|
||||
@hp = maxhp
|
||||
@sp = maxsp
|
||||
@hidden = troop.members[@member_index].hidden
|
||||
@immortal = troop.members[@member_index].immortal
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Enemy ID
|
||||
#--------------------------------------------------------------------------
|
||||
def id
|
||||
return @enemy_id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Index
|
||||
#--------------------------------------------------------------------------
|
||||
def index
|
||||
return @member_index
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Name
|
||||
#--------------------------------------------------------------------------
|
||||
def name
|
||||
return $data_enemies[@enemy_id].name
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Maximum HP
|
||||
#--------------------------------------------------------------------------
|
||||
def base_maxhp
|
||||
return $data_enemies[@enemy_id].maxhp
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Maximum SP
|
||||
#--------------------------------------------------------------------------
|
||||
def base_maxsp
|
||||
return $data_enemies[@enemy_id].maxsp
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Strength
|
||||
#--------------------------------------------------------------------------
|
||||
def base_str
|
||||
return $data_enemies[@enemy_id].str
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Dexterity
|
||||
#--------------------------------------------------------------------------
|
||||
def base_dex
|
||||
return $data_enemies[@enemy_id].dex
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Agility
|
||||
#--------------------------------------------------------------------------
|
||||
def base_agi
|
||||
return $data_enemies[@enemy_id].agi
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Intelligence
|
||||
#--------------------------------------------------------------------------
|
||||
def base_int
|
||||
return $data_enemies[@enemy_id].int
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Attack Power
|
||||
#--------------------------------------------------------------------------
|
||||
def base_atk
|
||||
return $data_enemies[@enemy_id].atk
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Physical Defense
|
||||
#--------------------------------------------------------------------------
|
||||
def base_pdef
|
||||
return $data_enemies[@enemy_id].pdef
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Magic Defense
|
||||
#--------------------------------------------------------------------------
|
||||
def base_mdef
|
||||
return $data_enemies[@enemy_id].mdef
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Basic Evasion
|
||||
#--------------------------------------------------------------------------
|
||||
def base_eva
|
||||
return $data_enemies[@enemy_id].eva
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Offensive Animation ID for Normal Attack
|
||||
#--------------------------------------------------------------------------
|
||||
def animation1_id
|
||||
return $data_enemies[@enemy_id].animation1_id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Target Animation ID for Normal Attack
|
||||
#--------------------------------------------------------------------------
|
||||
def animation2_id
|
||||
return $data_enemies[@enemy_id].animation2_id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Element Revision Value
|
||||
# element_id : Element ID
|
||||
#--------------------------------------------------------------------------
|
||||
def element_rate(element_id)
|
||||
# Get a numerical value corresponding to element effectiveness
|
||||
table = [0,200,150,100,50,0,-100]
|
||||
result = table[$data_enemies[@enemy_id].element_ranks[element_id]]
|
||||
# If protected by state, this element is reduced by half
|
||||
for i in @states
|
||||
if $data_states[i].guard_element_set.include?(element_id)
|
||||
result /= 2
|
||||
end
|
||||
end
|
||||
# End Method
|
||||
return result
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get State Effectiveness
|
||||
#--------------------------------------------------------------------------
|
||||
def state_ranks
|
||||
return $data_enemies[@enemy_id].state_ranks
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Determine State Guard
|
||||
# state_id : state ID
|
||||
#--------------------------------------------------------------------------
|
||||
def state_guard?(state_id)
|
||||
return false
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Normal Attack Element
|
||||
#--------------------------------------------------------------------------
|
||||
def element_set
|
||||
return []
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Normal Attack State Change (+)
|
||||
#--------------------------------------------------------------------------
|
||||
def plus_state_set
|
||||
return []
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Normal Attack State Change (-)
|
||||
#--------------------------------------------------------------------------
|
||||
def minus_state_set
|
||||
return []
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Aquire Actions
|
||||
#--------------------------------------------------------------------------
|
||||
def actions
|
||||
return $data_enemies[@enemy_id].actions
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get EXP
|
||||
#--------------------------------------------------------------------------
|
||||
def exp
|
||||
return $data_enemies[@enemy_id].exp
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Gold
|
||||
#--------------------------------------------------------------------------
|
||||
def gold
|
||||
return $data_enemies[@enemy_id].gold
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Item ID
|
||||
#--------------------------------------------------------------------------
|
||||
def item_id
|
||||
return $data_enemies[@enemy_id].item_id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Weapon ID
|
||||
#--------------------------------------------------------------------------
|
||||
def weapon_id
|
||||
return $data_enemies[@enemy_id].weapon_id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Armor ID
|
||||
#--------------------------------------------------------------------------
|
||||
def armor_id
|
||||
return $data_enemies[@enemy_id].armor_id
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Treasure Appearance Probability
|
||||
#--------------------------------------------------------------------------
|
||||
def treasure_prob
|
||||
return $data_enemies[@enemy_id].treasure_prob
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Battle Screen X-Coordinate
|
||||
#--------------------------------------------------------------------------
|
||||
def screen_x
|
||||
return $data_troops[@troop_id].members[@member_index].x
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Battle Screen Y-Coordinate
|
||||
#--------------------------------------------------------------------------
|
||||
def screen_y
|
||||
return $data_troops[@troop_id].members[@member_index].y
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Get Battle Screen Z-Coordinate
|
||||
#--------------------------------------------------------------------------
|
||||
def screen_z
|
||||
return screen_y
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Escape
|
||||
#--------------------------------------------------------------------------
|
||||
def escape
|
||||
# Set hidden flag
|
||||
@hidden = true
|
||||
# Clear current action
|
||||
self.current_action.clear
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Transform
|
||||
# enemy_id : ID of enemy to be transformed
|
||||
#--------------------------------------------------------------------------
|
||||
def transform(enemy_id)
|
||||
# Change enemy ID
|
||||
@enemy_id = enemy_id
|
||||
# Change battler graphics
|
||||
@battler_name = $data_enemies[@enemy_id].battler_name
|
||||
@battler_hue = $data_enemies[@enemy_id].battler_hue
|
||||
# Remake action
|
||||
make_action
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Make Action
|
||||
#--------------------------------------------------------------------------
|
||||
def make_action
|
||||
# Clear current action
|
||||
self.current_action.clear
|
||||
# If unable to move
|
||||
unless self.movable?
|
||||
# End Method
|
||||
return
|
||||
end
|
||||
# Extract current effective actions
|
||||
available_actions = []
|
||||
rating_max = 0
|
||||
for action in self.actions
|
||||
# Confirm turn conditions
|
||||
n = $game_temp.battle_turn
|
||||
a = action.condition_turn_a
|
||||
b = action.condition_turn_b
|
||||
if (b == 0 and n != a) or
|
||||
(b > 0 and (n < 1 or n < a or n % b != a % b))
|
||||
next
|
||||
end
|
||||
# Confirm HP conditions
|
||||
if self.hp * 100.0 / self.maxhp > action.condition_hp
|
||||
next
|
||||
end
|
||||
# Confirm level conditions
|
||||
if $game_party.max_level < action.condition_level
|
||||
next
|
||||
end
|
||||
# Confirm switch conditions
|
||||
switch_id = action.condition_switch_id
|
||||
if switch_id > 0 and $game_switches[switch_id] == false
|
||||
next
|
||||
end
|
||||
# Add this action to applicable conditions
|
||||
available_actions.push(action)
|
||||
if action.rating > rating_max
|
||||
rating_max = action.rating
|
||||
end
|
||||
end
|
||||
# Calculate total with max rating value at 3 (exclude 0 or less)
|
||||
ratings_total = 0
|
||||
for action in available_actions
|
||||
if action.rating > rating_max - 3
|
||||
ratings_total += action.rating - (rating_max - 3)
|
||||
end
|
||||
end
|
||||
# If ratings total isn't 0
|
||||
if ratings_total > 0
|
||||
# Create random numbers
|
||||
value = rand(ratings_total)
|
||||
# Set things that correspond to created random numbers as current action
|
||||
for action in available_actions
|
||||
if action.rating > rating_max - 3
|
||||
if value < action.rating - (rating_max - 3)
|
||||
self.current_action.kind = action.kind
|
||||
self.current_action.basic = action.basic
|
||||
self.current_action.skill_id = action.skill_id
|
||||
self.current_action.decide_random_target_for_enemy
|
||||
return
|
||||
else
|
||||
value -= action.rating - (rating_max - 3)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -162,19 +162,7 @@ class Interpreter
|
|||
battler.current_action.skill_id = @parameters[3]
|
||||
end
|
||||
# Set action target
|
||||
if @parameters[4] == -2
|
||||
if battler.is_a?(Game_Enemy)
|
||||
battler.current_action.decide_last_target_for_enemy
|
||||
else
|
||||
battler.current_action.decide_last_target_for_actor
|
||||
end
|
||||
elsif @parameters[4] == -1
|
||||
if battler.is_a?(Game_Enemy)
|
||||
battler.current_action.decide_random_target_for_enemy
|
||||
else
|
||||
battler.current_action.decide_random_target_for_actor
|
||||
end
|
||||
elsif @parameters[4] >= 0
|
||||
if @parameters[4] >= 0
|
||||
battler.current_action.target_index = @parameters[4]
|
||||
end
|
||||
# Set force flag
|
||||
|
|
|
|||
|
|
@ -1,108 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** 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.x = (Graphica.width / 2) - @command_window.width / 2
|
||||
@command_window.y = (Graphica.height / 2) - @command_window.height / 2
|
||||
# Execute transition
|
||||
Graphics.transition
|
||||
# Main loop
|
||||
while true
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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
|
||||
|
|
@ -1,222 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** 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
|
||||
@left_window = Window_EquipLeft.new(@actor)
|
||||
@right_window = Window_EquipRight.new(@actor)
|
||||
@item_window1 = Window_EquipItem.new(@actor, 0)
|
||||
@item_window2 = Window_EquipItem.new(@actor, 1)
|
||||
@item_window3 = Window_EquipItem.new(@actor, 2)
|
||||
@item_window4 = Window_EquipItem.new(@actor, 3)
|
||||
@item_window5 = Window_EquipItem.new(@actor, 4)
|
||||
# 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
|
||||
while true
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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
|
||||
|
|
@ -1,131 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Scene_File
|
||||
#------------------------------------------------------------------------------
|
||||
# This is a superclass for the save screen and load screen.
|
||||
#==============================================================================
|
||||
|
||||
class Scene_File
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# help_text : text string shown in the help window
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(help_text)
|
||||
@help_text = help_text
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Main Processing
|
||||
#--------------------------------------------------------------------------
|
||||
def main
|
||||
# Make help window
|
||||
@help_window = Window_Help.new
|
||||
@help_window.set_text(@help_text)
|
||||
# Make save file window
|
||||
@savefile_windows = []
|
||||
for i in 0..99
|
||||
@savefile_windows.push(Window_SaveFile.new(i, make_filename(i)))
|
||||
end
|
||||
# Select last file to be operated
|
||||
@file_index = $game_temp.last_file_index
|
||||
@savefile_windows[@file_index].selected = true
|
||||
updateVisibleSavefileWindows
|
||||
# Execute transition
|
||||
Graphics.transition
|
||||
# Main loop
|
||||
while true
|
||||
# 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
|
||||
for i in @savefile_windows
|
||||
i.dispose
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Frame Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update
|
||||
# Update windows
|
||||
@help_window.update
|
||||
for i in @savefile_windows
|
||||
i.update
|
||||
end
|
||||
# If C button was pressed
|
||||
if Input.trigger?(Input::ACTION)
|
||||
# Call method: on_decision (defined by the subclasses)
|
||||
on_decision(make_filename(@file_index))
|
||||
$game_temp.last_file_index = @file_index
|
||||
return
|
||||
end
|
||||
# If B button was pressed
|
||||
if Input.trigger?(Input::CANCEL)
|
||||
# Call method: on_cancel (defined by the subclasses)
|
||||
on_cancel
|
||||
return
|
||||
end
|
||||
# If the down directional button was pressed
|
||||
if Input.repeat?(Input::DOWN)
|
||||
# If the down directional button pressed down is not a repeat,
|
||||
# or cursor position is more in front than 3
|
||||
if Input.trigger?(Input::DOWN) or @file_index < 99
|
||||
# Play cursor SE
|
||||
$game_system.se_play($data_system.cursor_se)
|
||||
# Move cursor down
|
||||
@savefile_windows[@file_index].selected = false
|
||||
@file_index = (@file_index + 1)
|
||||
if @file_index > 99
|
||||
@file_index = 0
|
||||
end
|
||||
@savefile_windows[@file_index].selected = true
|
||||
updateVisibleSavefileWindows
|
||||
return
|
||||
end
|
||||
end
|
||||
# If the up directional button was pressed
|
||||
if Input.repeat?(Input::UP)
|
||||
# If the up directional button pressed down is not a repeat、
|
||||
# or cursor position is more in back than 0
|
||||
if Input.trigger?(Input::UP) or @file_index > 0
|
||||
# Play cursor SE
|
||||
$game_system.se_play($data_system.cursor_se)
|
||||
# Move cursor up
|
||||
@savefile_windows[@file_index].selected = false
|
||||
@file_index = (@file_index - 1)
|
||||
if @file_index < 0
|
||||
@file_index = 99
|
||||
end
|
||||
@savefile_windows[@file_index].selected = true
|
||||
updateVisibleSavefileWindows
|
||||
return
|
||||
end
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Make File Name
|
||||
# file_index : save file index (0-3)
|
||||
#--------------------------------------------------------------------------
|
||||
def make_filename(file_index)
|
||||
return "Save#{file_index + 1}.rxdata"
|
||||
end
|
||||
|
||||
def updateVisibleSavefileWindows
|
||||
for i in 0..99
|
||||
@savefile_windows[i].visible = false
|
||||
end
|
||||
|
||||
screen_start_index = @file_index - (@file_index % 4)
|
||||
for i in screen_start_index..(screen_start_index + 3)
|
||||
@savefile_windows[i].visible = true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,205 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** 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
|
||||
# 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
|
||||
while true
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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
|
||||
|
|
@ -1,116 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Scene_Load
|
||||
#------------------------------------------------------------------------------
|
||||
# This class performs load screen processing.
|
||||
#==============================================================================
|
||||
|
||||
class Scene_Load < Scene_File
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
# Remake temporary object
|
||||
$game_temp = Game_Temp.new
|
||||
# Timestamp selects new file
|
||||
$game_temp.last_file_index = 0
|
||||
latest_time = CTime.at(0)
|
||||
for i in 0..99
|
||||
filename = make_filename(i)
|
||||
if FileTest.exist?(filename)
|
||||
file = File.open(filename, "r")
|
||||
if file.mtime > latest_time
|
||||
latest_time = file.mtime
|
||||
$game_temp.last_file_index = i
|
||||
end
|
||||
file.close
|
||||
end
|
||||
end
|
||||
super("Which file would you like to load?")
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Decision Processing
|
||||
#--------------------------------------------------------------------------
|
||||
def on_decision(filename)
|
||||
# If file doesn't exist
|
||||
unless FileTest.exist?(filename)
|
||||
# Play buzzer SE
|
||||
$game_system.se_play($data_system.buzzer_se)
|
||||
return
|
||||
end
|
||||
# Play load SE
|
||||
$game_system.se_play($data_system.load_se)
|
||||
# Read save data
|
||||
file = File.open(filename, "rb")
|
||||
read_save_data(file)
|
||||
file.close
|
||||
# Restore BGM and BGS
|
||||
$game_system.bgm_play($game_system.playing_bgm)
|
||||
$game_system.bgs_play($game_system.playing_bgs)
|
||||
# Update map (run parallel process event)
|
||||
$game_map.update
|
||||
# Switch to map screen
|
||||
$scene = Scene_Map.new
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Cancel Processing
|
||||
#--------------------------------------------------------------------------
|
||||
def on_cancel
|
||||
# Play cancel SE
|
||||
$game_system.se_play($data_system.cancel_se)
|
||||
# Switch to title screen
|
||||
$scene = Scene_Map.new
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Read Save Data
|
||||
# file : file object for reading (opened)
|
||||
#--------------------------------------------------------------------------
|
||||
def read_save_data(file)
|
||||
# Read character data for drawing save file
|
||||
characters = Marshal.load(file)
|
||||
# Read frame count for measuring play time
|
||||
Graphics.frame_count = Marshal.load(file)
|
||||
# Read each type of game object
|
||||
$game_system = Marshal.load(file)
|
||||
$game_switches = Marshal.load(file)
|
||||
$game_variables = Marshal.load(file)
|
||||
$game_self_switches = Marshal.load(file)
|
||||
$game_screen = Marshal.load(file)
|
||||
$game_actors = Marshal.load(file)
|
||||
$game_party = Marshal.load(file)
|
||||
$game_troop = Marshal.load(file)
|
||||
$game_map = Marshal.load(file)
|
||||
$game_player = Marshal.load(file)
|
||||
$game_followers = Marshal.load(file)
|
||||
$game_oneshot = Marshal.load(file)
|
||||
$game_fasttravel = Marshal.load(file)
|
||||
$game_temp.footstep_sfx = Marshal.load(file)
|
||||
|
||||
# If magic number is different from when saving
|
||||
# (if editing was added with editor)
|
||||
if $game_system.magic_number != $data_system.magic_number
|
||||
# Load map
|
||||
$game_map.setup($game_map.map_id)
|
||||
$game_player.center($game_player.x, $game_player.y)
|
||||
end
|
||||
# Refresh party members
|
||||
$game_party.refresh
|
||||
|
||||
f_prev = $game_player
|
||||
for f in $game_followers
|
||||
f.leader = f_prev
|
||||
f.moveto($game_player.x, $game_player.y)
|
||||
f_prev = f
|
||||
end
|
||||
|
||||
|
||||
# check for debug file to add debug items
|
||||
if Settings[:debug] = true
|
||||
# debug save
|
||||
$game_party.gain_item(54, 1)
|
||||
# plight skip
|
||||
$game_party.gain_item(82, 1)
|
||||
end
|
||||
|
||||
load_perma_flags
|
||||
end
|
||||
end
|
||||
|
|
@ -447,15 +447,6 @@ class Scene_Map
|
|||
@window_settings.open
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Save Call
|
||||
#--------------------------------------------------------------------------
|
||||
def call_save
|
||||
# Straighten player position
|
||||
$game_player.straighten
|
||||
# Switch to save screen
|
||||
$scene = Scene_Save.new
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Debug Call
|
||||
#--------------------------------------------------------------------------
|
||||
def call_debug
|
||||
|
|
|
|||
|
|
@ -1,213 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Scene_Menu
|
||||
#------------------------------------------------------------------------------
|
||||
# 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.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.x = 0
|
||||
@playtime_window.y = 224
|
||||
# Make steps window
|
||||
@steps_window = Window_Steps.new
|
||||
@steps_window.x = 0
|
||||
@steps_window.y = 320
|
||||
# Make gold window
|
||||
@gold_window = Window_Gold.new
|
||||
@gold_window.x = 0
|
||||
@gold_window.y = 416
|
||||
# Make status window
|
||||
@status_window = Window_MenuStatus.new
|
||||
@status_window.x = 160
|
||||
@status_window.y = 0
|
||||
# Execute transition
|
||||
Graphics.transition
|
||||
# Main loop
|
||||
while true
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Scene_Save
|
||||
#------------------------------------------------------------------------------
|
||||
# This class performs save screen processing.
|
||||
#==============================================================================
|
||||
|
||||
class Scene_Save < Scene_File
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super("Which file would you like to save to?")
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Decision Processing
|
||||
#--------------------------------------------------------------------------
|
||||
def on_decision(filename)
|
||||
# Play save SE
|
||||
$game_system.se_play($data_system.save_se)
|
||||
# Write save data
|
||||
file = File.open(filename, "wb")
|
||||
write_save_data(file)
|
||||
file.close
|
||||
# If called from event
|
||||
if $game_temp.save_calling
|
||||
# Clear save call flag
|
||||
$game_temp.save_calling = false
|
||||
# Switch to map screen
|
||||
$scene = Scene_Map.new
|
||||
return
|
||||
end
|
||||
# Switch to menu screen
|
||||
$scene = Scene_Menu.new(4)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Cancel Processing
|
||||
#--------------------------------------------------------------------------
|
||||
def on_cancel
|
||||
# Play cancel SE
|
||||
$game_system.se_play($data_system.cancel_se)
|
||||
# If called from event
|
||||
if $game_temp.save_calling
|
||||
# Clear save call flag
|
||||
$game_temp.save_calling = false
|
||||
# Switch to map screen
|
||||
$scene = Scene_Map.new
|
||||
return
|
||||
end
|
||||
# Switch to menu screen
|
||||
$scene = Scene_Menu.new(4)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Write Save Data
|
||||
# file : write file object (opened)
|
||||
#--------------------------------------------------------------------------
|
||||
def write_save_data(file)
|
||||
# Make character data for drawing save file
|
||||
characters = []
|
||||
for i in 0...$game_party.actors.size
|
||||
actor = $game_party.actors[i]
|
||||
characters.push([actor.character_name, actor.character_hue])
|
||||
end
|
||||
# Write character data for drawing save file
|
||||
Marshal.dump(characters, file)
|
||||
# Wrire frame count for measuring play time
|
||||
Marshal.dump(Graphics.frame_count, file)
|
||||
# Increase save count by 1
|
||||
$game_system.save_count += 1
|
||||
# Save magic number
|
||||
# (A random value will be written each time saving with editor)
|
||||
$game_system.magic_number = $data_system.magic_number
|
||||
# Write each type of game object
|
||||
Marshal.dump($game_system, file)
|
||||
Marshal.dump($game_switches, file)
|
||||
Marshal.dump($game_variables, file)
|
||||
Marshal.dump($game_self_switches, file)
|
||||
Marshal.dump($game_screen, file)
|
||||
Marshal.dump($game_actors, file)
|
||||
Marshal.dump($game_party, file)
|
||||
Marshal.dump($game_troop, file)
|
||||
Marshal.dump($game_map, file)
|
||||
Marshal.dump($game_player, file)
|
||||
Marshal.dump($game_followers, file)
|
||||
Marshal.dump($game_oneshot, file)
|
||||
Marshal.dump($game_fasttravel, file)
|
||||
Marshal.dump($game_temp.footstep_sfx , file)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,232 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** 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
|
||||
@status_window = Window_SkillStatus.new(@actor)
|
||||
@skill_window = Window_Skill.new(@actor)
|
||||
# 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
|
||||
while true
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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::CANCEL)
|
||||
# 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::ACTION)
|
||||
# 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
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Scene_Status
|
||||
#------------------------------------------------------------------------------
|
||||
# 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)
|
||||
# Execute transition
|
||||
Graphics.transition
|
||||
# Main loop
|
||||
while true
|
||||
# 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::CANCEL)
|
||||
# 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
|
||||
|
|
@ -1,131 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Sprite_Battler
|
||||
#------------------------------------------------------------------------------
|
||||
# This sprite is used to display the battler.It observes the Game_Character
|
||||
# class and automatically changes sprite conditions.
|
||||
#==============================================================================
|
||||
|
||||
class Sprite_Battler < RPG::Sprite
|
||||
#--------------------------------------------------------------------------
|
||||
# * Public Instance Variables
|
||||
#--------------------------------------------------------------------------
|
||||
attr_accessor :battler # battler
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# viewport : viewport
|
||||
# battler : battler (Game_Battler)
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(viewport, battler = nil)
|
||||
super(viewport)
|
||||
@battler = battler
|
||||
@battler_visible = false
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Dispose
|
||||
#--------------------------------------------------------------------------
|
||||
def dispose
|
||||
if self.bitmap != nil
|
||||
self.bitmap.dispose
|
||||
end
|
||||
super
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Frame Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update
|
||||
super
|
||||
# If battler is nil
|
||||
if @battler == nil
|
||||
self.bitmap = nil
|
||||
loop_animation(nil)
|
||||
return
|
||||
end
|
||||
# If file name or hue are different than current ones
|
||||
if @battler.battler_name != @battler_name or
|
||||
@battler.battler_hue != @battler_hue
|
||||
# Get and set bitmap
|
||||
@battler_name = @battler.battler_name
|
||||
@battler_hue = @battler.battler_hue
|
||||
self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
|
||||
@width = bitmap.width
|
||||
@height = bitmap.height
|
||||
self.ox = @width / 2
|
||||
self.oy = @height
|
||||
# Change opacity level to 0 when dead or hidden
|
||||
if @battler.dead? or @battler.hidden
|
||||
self.opacity = 0
|
||||
end
|
||||
end
|
||||
# If animation ID is different than current one
|
||||
if @battler.damage == nil and
|
||||
@battler.state_animation_id != @state_animation_id
|
||||
@state_animation_id = @battler.state_animation_id
|
||||
loop_animation($data_animations[@state_animation_id])
|
||||
end
|
||||
# If actor which should be displayed
|
||||
if @battler.is_a?(Game_Actor) and @battler_visible
|
||||
# Bring opacity level down a bit when not in main phase
|
||||
if $game_temp.battle_main_phase
|
||||
self.opacity += 3 if self.opacity < 255
|
||||
else
|
||||
self.opacity -= 3 if self.opacity > 207
|
||||
end
|
||||
end
|
||||
# Blink
|
||||
if @battler.blink
|
||||
blink_on
|
||||
else
|
||||
blink_off
|
||||
end
|
||||
# If invisible
|
||||
unless @battler_visible
|
||||
# Appear
|
||||
if not @battler.hidden and not @battler.dead? and
|
||||
(@battler.damage == nil or @battler.damage_pop)
|
||||
appear
|
||||
@battler_visible = true
|
||||
end
|
||||
end
|
||||
# If visible
|
||||
if @battler_visible
|
||||
# Escape
|
||||
if @battler.hidden
|
||||
$game_system.se_play($data_system.escape_se)
|
||||
escape
|
||||
@battler_visible = false
|
||||
end
|
||||
# White flash
|
||||
if @battler.white_flash
|
||||
whiten
|
||||
@battler.white_flash = false
|
||||
end
|
||||
# Animation
|
||||
if @battler.animation_id != 0
|
||||
animation = $data_animations[@battler.animation_id]
|
||||
animation(animation, @battler.animation_hit)
|
||||
@battler.animation_id = 0
|
||||
end
|
||||
# Damage
|
||||
if @battler.damage_pop
|
||||
damage(@battler.damage, @battler.critical)
|
||||
@battler.damage = nil
|
||||
@battler.critical = false
|
||||
@battler.damage_pop = false
|
||||
end
|
||||
# Collapse
|
||||
if @battler.damage == nil and @battler.dead?
|
||||
if @battler.is_a?(Game_Enemy)
|
||||
$game_system.se_play($data_system.enemy_collapse_se)
|
||||
else
|
||||
$game_system.se_play($data_system.actor_collapse_se)
|
||||
end
|
||||
collapse
|
||||
@battler_visible = false
|
||||
end
|
||||
end
|
||||
# Set sprite coordinates
|
||||
self.x = @battler.screen_x
|
||||
self.y = @battler.screen_y
|
||||
self.z = @battler.screen_z
|
||||
end
|
||||
end
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_BattleResult
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays amount of gold and EXP acquired at the end of a battle.
|
||||
#==============================================================================
|
||||
|
||||
class Window_BattleResult < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# exp : EXP
|
||||
# gold : amount of gold
|
||||
# treasures : treasures
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(exp, gold, treasures)
|
||||
@exp = exp
|
||||
@gold = gold
|
||||
@treasures = treasures
|
||||
super(160, 0, 320, @treasures.size * 32 + 64)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
self.y = 160 - height / 2
|
||||
self.back_opacity = 160
|
||||
self.visible = false
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
x = 4
|
||||
self.contents.font.color = normal_color
|
||||
cx = contents.text_size(@exp.to_s).width
|
||||
self.contents.draw_text(x, 0, cx, 32, @exp.to_s)
|
||||
x += cx + 4
|
||||
self.contents.font.color = system_color
|
||||
cx = contents.text_size("EXP").width
|
||||
self.contents.draw_text(x, 0, 64, 32, "EXP")
|
||||
x += cx + 16
|
||||
self.contents.font.color = normal_color
|
||||
cx = contents.text_size(@gold.to_s).width
|
||||
self.contents.draw_text(x, 0, cx, 32, @gold.to_s)
|
||||
x += cx + 4
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(x, 0, 128, 32, $data_system.words.gold)
|
||||
y = 32
|
||||
for item in @treasures
|
||||
draw_item_name(item, 4, y)
|
||||
y += 32
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_BattleStatus
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays the status of all party members on the battle screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_BattleStatus < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 320, 640, 160)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@level_up_flags = [false, false, false, false]
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Dispose
|
||||
#--------------------------------------------------------------------------
|
||||
def dispose
|
||||
super
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Level Up Flag
|
||||
# actor_index : actor index
|
||||
#--------------------------------------------------------------------------
|
||||
def level_up(actor_index)
|
||||
@level_up_flags[actor_index] = true
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
@item_max = $game_party.actors.size
|
||||
for i in 0...$game_party.actors.size
|
||||
actor = $game_party.actors[i]
|
||||
actor_x = i * 160 + 4
|
||||
draw_actor_name(actor, actor_x, 0)
|
||||
draw_actor_hp(actor, actor_x, 32, 120)
|
||||
draw_actor_sp(actor, actor_x, 64, 120)
|
||||
if @level_up_flags[i]
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(actor_x, 96, 120, 32, "LEVEL UP!")
|
||||
else
|
||||
draw_actor_state(actor, actor_x, 96)
|
||||
end
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Frame Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update
|
||||
super
|
||||
# Slightly lower opacity level during main phase
|
||||
if $game_temp.battle_main_phase
|
||||
self.contents_opacity -= 4 if self.contents_opacity > 191
|
||||
else
|
||||
self.contents_opacity += 4 if self.contents_opacity < 255
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_Command
|
||||
#------------------------------------------------------------------------------
|
||||
# This window deals with general command choices.
|
||||
#==============================================================================
|
||||
|
||||
class Window_Command < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# width : window width
|
||||
# commands : command text string array
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(width, commands)
|
||||
# Compute window height from command quantity
|
||||
super(0, 0, width, commands.size * 32 + 32)
|
||||
@item_max = commands.size
|
||||
@commands = commands
|
||||
self.contents = Bitmap.new(width - 32, @item_max * 32)
|
||||
refresh
|
||||
self.index = 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
for i in 0...@item_max
|
||||
draw_item(i, normal_color)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Draw Item
|
||||
# index : item number
|
||||
# color : text color
|
||||
#--------------------------------------------------------------------------
|
||||
def draw_item(index, color)
|
||||
self.contents.font.color = color
|
||||
rect = Rect.new(4, 32 * index, self.contents.width - 8, 32)
|
||||
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
|
||||
self.contents.draw_text(rect, @commands[index])
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Disable Item
|
||||
# index : item number
|
||||
#--------------------------------------------------------------------------
|
||||
def disable_item(index)
|
||||
draw_item(index, disabled_color)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_EquipItem
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays choices when opting to change equipment on the
|
||||
# equipment screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_EquipItem < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# actor : actor
|
||||
# equip_type : equip region (0-3)
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(actor, equip_type)
|
||||
super(0, 256, 640, 224)
|
||||
@actor = actor
|
||||
@equip_type = equip_type
|
||||
@column_max = 2
|
||||
refresh
|
||||
self.active = false
|
||||
self.index = -1
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Item Acquisition
|
||||
#--------------------------------------------------------------------------
|
||||
def item
|
||||
return @data[self.index]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
if self.contents != nil
|
||||
self.contents.dispose
|
||||
self.contents = nil
|
||||
end
|
||||
@data = []
|
||||
# Add equippable weapons
|
||||
if @equip_type == 0
|
||||
weapon_set = $data_classes[@actor.class_id].weapon_set
|
||||
for i in 1...$data_weapons.size
|
||||
if $game_party.weapon_number(i) > 0 and weapon_set.include?(i)
|
||||
@data.push($data_weapons[i])
|
||||
end
|
||||
end
|
||||
end
|
||||
# Add equippable armor
|
||||
if @equip_type != 0
|
||||
armor_set = $data_classes[@actor.class_id].armor_set
|
||||
for i in 1...$data_armors.size
|
||||
if $game_party.armor_number(i) > 0 and armor_set.include?(i)
|
||||
if $data_armors[i].kind == @equip_type-1
|
||||
@data.push($data_armors[i])
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
# Add blank page
|
||||
@data.push(nil)
|
||||
# Make a bit map and draw all items
|
||||
@item_max = @data.size
|
||||
self.contents = Bitmap.new(width - 32, row_max * 32)
|
||||
for i in 0...@item_max-1
|
||||
draw_item(i)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Draw Item
|
||||
# index : item number
|
||||
#--------------------------------------------------------------------------
|
||||
def draw_item(index)
|
||||
item = @data[index]
|
||||
x = 4 + index % 2 * (288 + 32)
|
||||
y = index / 2 * 32
|
||||
case item
|
||||
when RPG::Weapon
|
||||
number = $game_party.weapon_number(item.id)
|
||||
when RPG::Armor
|
||||
number = $game_party.armor_number(item.id)
|
||||
end
|
||||
bitmap = RPG::Cache.icon(item.icon_name)
|
||||
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
|
||||
self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
|
||||
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Help Text Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_help
|
||||
@help_window.set_text(self.item == nil ? "" : self.item.description)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,61 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_EquipLeft
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays actor parameter changes on the equipment screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_EquipLeft < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# actor : actor
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(actor)
|
||||
super(0, 64, 272, 192)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@actor = actor
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
draw_actor_name(@actor, 4, 0)
|
||||
draw_actor_level(@actor, 4, 32)
|
||||
draw_actor_parameter(@actor, 4, 64, 0)
|
||||
draw_actor_parameter(@actor, 4, 96, 1)
|
||||
draw_actor_parameter(@actor, 4, 128, 2)
|
||||
if @new_atk != nil
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(160, 64, 40, 32, "->", 1)
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(200, 64, 36, 32, @new_atk.to_s, 2)
|
||||
end
|
||||
if @new_pdef != nil
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(160, 96, 40, 32, "->", 1)
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(200, 96, 36, 32, @new_pdef.to_s, 2)
|
||||
end
|
||||
if @new_mdef != nil
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(160, 128, 40, 32, "->", 1)
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(200, 128, 36, 32, @new_mdef.to_s, 2)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set parameters after changing equipment
|
||||
# new_atk : attack power after changing equipment
|
||||
# new_pdef : physical defense after changing equipment
|
||||
# new_mdef : magic defense after changing equipment
|
||||
#--------------------------------------------------------------------------
|
||||
def set_new_parameters(new_atk, new_pdef, new_mdef)
|
||||
if @new_atk != new_atk or @new_pdef != new_pdef or @new_mdef != new_mdef
|
||||
@new_atk = new_atk
|
||||
@new_pdef = new_pdef
|
||||
@new_mdef = new_mdef
|
||||
refresh
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,56 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_EquipRight
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays items the actor is currently equipped with on the
|
||||
# equipment screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_EquipRight < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# actor : actor
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(actor)
|
||||
super(272, 64, 368, 192)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@actor = actor
|
||||
refresh
|
||||
self.index = 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Item Acquisition
|
||||
#--------------------------------------------------------------------------
|
||||
def item
|
||||
return @data[self.index]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
@data = []
|
||||
@data.push($data_weapons[@actor.weapon_id])
|
||||
@data.push($data_armors[@actor.armor1_id])
|
||||
@data.push($data_armors[@actor.armor2_id])
|
||||
@data.push($data_armors[@actor.armor3_id])
|
||||
@data.push($data_armors[@actor.armor4_id])
|
||||
@item_max = @data.size
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(4, 32 * 0, 92, 32, $data_system.words.weapon)
|
||||
self.contents.draw_text(4, 32 * 1, 92, 32, $data_system.words.armor1)
|
||||
self.contents.draw_text(4, 32 * 2, 92, 32, $data_system.words.armor2)
|
||||
self.contents.draw_text(4, 32 * 3, 92, 32, $data_system.words.armor3)
|
||||
self.contents.draw_text(5, 32 * 4, 92, 32, $data_system.words.armor4)
|
||||
draw_item_name(@data[0], 92, 32 * 0)
|
||||
draw_item_name(@data[1], 92, 32 * 1)
|
||||
draw_item_name(@data[2], 92, 32 * 2)
|
||||
draw_item_name(@data[3], 92, 32 * 3)
|
||||
draw_item_name(@data[4], 92, 32 * 4)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Help Text Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_help
|
||||
@help_window.set_text(self.item == nil ? "" : self.item.description)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,27 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_Gold
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays amount of gold.
|
||||
#==============================================================================
|
||||
|
||||
class Window_Gold < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 0, 160, 64)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
cx = contents.text_size($data_system.words.gold).width
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(4, 0, 120-cx-2, 32, $game_party.gold.to_s, 2)
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(124-cx, 0, cx, 32, $data_system.words.gold, 2)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_MenuStatus
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays party member status on the menu screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_MenuStatus < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 0, 480, 480)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
refresh
|
||||
self.active = false
|
||||
self.index = -1
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
@item_max = $game_party.actors.size
|
||||
for i in 0...$game_party.actors.size
|
||||
x = 64
|
||||
y = i * 116
|
||||
actor = $game_party.actors[i]
|
||||
draw_actor_graphic(actor, x - 40, y + 80)
|
||||
draw_actor_name(actor, x, y)
|
||||
draw_actor_class(actor, x + 144, y)
|
||||
draw_actor_level(actor, x, y + 32)
|
||||
draw_actor_state(actor, x + 90, y + 32)
|
||||
draw_actor_exp(actor, x, y + 64)
|
||||
draw_actor_hp(actor, x + 236, y + 32)
|
||||
draw_actor_sp(actor, x + 236, y + 64)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Cursor Rectangle Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_cursor_rect
|
||||
if @index < 0
|
||||
self.cursor_rect.empty
|
||||
else
|
||||
self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_PartyCommand
|
||||
#------------------------------------------------------------------------------
|
||||
# This window is used to select whether to fight or escape on the battle
|
||||
# screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_PartyCommand < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 0, 640, 64)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
self.back_opacity = 160
|
||||
@commands = ["Fight", "Escape"]
|
||||
@item_max = 2
|
||||
@column_max = 2
|
||||
draw_item(0, normal_color)
|
||||
draw_item(1, $game_temp.battle_can_escape ? normal_color : disabled_color)
|
||||
self.active = false
|
||||
self.visible = false
|
||||
self.index = 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Draw Item
|
||||
# index : item number
|
||||
# color : text character color
|
||||
#--------------------------------------------------------------------------
|
||||
def draw_item(index, color)
|
||||
self.contents.font.color = color
|
||||
rect = Rect.new(160 + index * 160 + 4, 0, 128 - 10, 32)
|
||||
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
|
||||
self.contents.draw_text(rect, @commands[index], 1)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Cursor Rectangle Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_cursor_rect
|
||||
self.cursor_rect.set(160 + index * 160, 0, 128, 32)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_PlayTime
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays play time on the menu screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_PlayTime < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 0, 160, 96)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(4, 0, 120, 32, "Play Time")
|
||||
@total_sec = Graphics.frame_count / Graphics.frame_rate
|
||||
hour = @total_sec / 60 / 60
|
||||
min = @total_sec / 60 % 60
|
||||
sec = @total_sec % 60
|
||||
text = sprintf("%02d:%02d:%02d", hour, min, sec)
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(4, 32, 120, 32, text, 2)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Frame Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update
|
||||
super
|
||||
if Graphics.frame_count / Graphics.frame_rate != @total_sec
|
||||
refresh
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_SaveFile
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays save files on the save and load screens.
|
||||
#==============================================================================
|
||||
|
||||
class Window_SaveFile < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Public Instance Variables
|
||||
#--------------------------------------------------------------------------
|
||||
attr_reader :filename # file name
|
||||
attr_reader :selected # selected
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# file_index : save file index (0-3)
|
||||
# filename : file name
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(file_index, filename)
|
||||
super(0, 64 + file_index % 4 * 104, 640, 104)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@file_index = file_index
|
||||
@filename = "Save#{@file_index + 1}.rxdata"
|
||||
@time_stamp = CTime.at(0)
|
||||
@file_exist = FileTest.exist?(@filename)
|
||||
if @file_exist
|
||||
file = File.open(@filename, "r")
|
||||
@time_stamp = file.mtime
|
||||
@characters = Marshal.load(file)
|
||||
@frame_count = Marshal.load(file)
|
||||
@game_system = Marshal.load(file)
|
||||
@game_switches = Marshal.load(file)
|
||||
@game_variables = Marshal.load(file)
|
||||
@total_sec = @frame_count / Graphics.frame_rate
|
||||
file.close
|
||||
end
|
||||
refresh
|
||||
@selected = false
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
# Draw file number
|
||||
self.contents.font.color = normal_color
|
||||
name = "File#{@file_index + 1}"
|
||||
self.contents.draw_text(4, 0, 600, 32, name)
|
||||
@name_width = contents.text_size(name).width
|
||||
# If save file exists
|
||||
if @file_exist
|
||||
# Draw character
|
||||
for i in 0...@characters.size
|
||||
bitmap = RPG::Cache.character(@characters[i][0], @characters[i][1])
|
||||
cw = bitmap.rect.width / 4
|
||||
ch = bitmap.rect.height / 4
|
||||
src_rect = Rect.new(0, 0, cw, ch)
|
||||
x = 300 - @characters.size * 32 + i * 64 - cw / 2
|
||||
self.contents.blt(x, 68 - ch, bitmap, src_rect)
|
||||
end
|
||||
# Draw play time
|
||||
hour = @total_sec / 60 / 60
|
||||
min = @total_sec / 60 % 60
|
||||
sec = @total_sec % 60
|
||||
time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(4, 8, 600, 32, time_string, 2)
|
||||
# Draw timestamp
|
||||
self.contents.font.color = normal_color
|
||||
time_string = @time_stamp.strftime("%Y/%m/%d %H:%M")
|
||||
self.contents.draw_text(4, 40, 600, 32, time_string, 2)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Selected
|
||||
# selected : new selected (true = selected, false = unselected)
|
||||
#--------------------------------------------------------------------------
|
||||
def selected=(selected)
|
||||
@selected = selected
|
||||
update_cursor_rect
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Cursor Rectangle Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_cursor_rect
|
||||
if @selected
|
||||
self.cursor_rect.set(0, 0, @name_width + 8, 32)
|
||||
else
|
||||
self.cursor_rect.empty
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_ShopBuy
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays buyable goods on the shop screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_ShopBuy < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# shop_goods : goods
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(shop_goods)
|
||||
super(0, 128, 368, 352)
|
||||
@shop_goods = shop_goods
|
||||
refresh
|
||||
self.index = 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Item Acquisition
|
||||
#--------------------------------------------------------------------------
|
||||
def item
|
||||
return @data[self.index]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
if self.contents != nil
|
||||
self.contents.dispose
|
||||
self.contents = nil
|
||||
end
|
||||
@data = []
|
||||
for goods_item in @shop_goods
|
||||
case goods_item[0]
|
||||
when 0
|
||||
item = $data_items[goods_item[1]]
|
||||
when 1
|
||||
item = $data_weapons[goods_item[1]]
|
||||
when 2
|
||||
item = $data_armors[goods_item[1]]
|
||||
end
|
||||
if item != nil
|
||||
@data.push(item)
|
||||
end
|
||||
end
|
||||
# If item count is not 0, make a bit map and draw all items
|
||||
@item_max = @data.size
|
||||
if @item_max > 0
|
||||
self.contents = Bitmap.new(width - 32, row_max * 32)
|
||||
for i in 0...@item_max
|
||||
draw_item(i)
|
||||
end
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Draw Item
|
||||
# index : item number
|
||||
#--------------------------------------------------------------------------
|
||||
def draw_item(index)
|
||||
item = @data[index]
|
||||
# Get items in possession
|
||||
case item
|
||||
when RPG::Item
|
||||
number = $game_party.item_number(item.id)
|
||||
when RPG::Weapon
|
||||
number = $game_party.weapon_number(item.id)
|
||||
when RPG::Armor
|
||||
number = $game_party.armor_number(item.id)
|
||||
end
|
||||
# If price is less than money in possession, and amount in possession is
|
||||
# not 99, then set to normal text color. Otherwise set to disabled color
|
||||
if item.price <= $game_party.gold and number < 99
|
||||
self.contents.font.color = normal_color
|
||||
else
|
||||
self.contents.font.color = disabled_color
|
||||
end
|
||||
x = 4
|
||||
y = index * 32
|
||||
rect = Rect.new(x, y, self.width - 32, 32)
|
||||
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
|
||||
bitmap = RPG::Cache.icon(item.icon_name)
|
||||
opacity = self.contents.font.color == normal_color ? 255 : 128
|
||||
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
|
||||
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
|
||||
self.contents.draw_text(x + 240, y, 88, 32, item.price.to_s, 2)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Help Text Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_help
|
||||
@help_window.set_text(self.item == nil ? "" : self.item.description)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_ShopCommand
|
||||
#------------------------------------------------------------------------------
|
||||
# This window is used to choose your business on the shop screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_ShopCommand < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 64, 480, 64)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@item_max = 3
|
||||
@column_max = 3
|
||||
@commands = ["Buy", "Sell", "Exit"]
|
||||
refresh
|
||||
self.index = 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
for i in 0...@item_max
|
||||
draw_item(i)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Draw Item
|
||||
# index : item number
|
||||
#--------------------------------------------------------------------------
|
||||
def draw_item(index)
|
||||
x = 4 + index * 160
|
||||
self.contents.draw_text(x, 0, 128, 32, @commands[index])
|
||||
end
|
||||
end
|
||||
|
|
@ -1,87 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_ShopNumber
|
||||
#------------------------------------------------------------------------------
|
||||
# This window is for inputting quantity of items to buy or sell on the
|
||||
# shop screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_ShopNumber < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 128, 368, 352)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@item = nil
|
||||
@max = 1
|
||||
@price = 0
|
||||
@number = 1
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Items, Max Quantity, and Price
|
||||
#--------------------------------------------------------------------------
|
||||
def set(item, max, price)
|
||||
@item = item
|
||||
@max = max
|
||||
@price = price
|
||||
@number = 1
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Inputted Quantity
|
||||
#--------------------------------------------------------------------------
|
||||
def number
|
||||
return @number
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
draw_item_name(@item, 4, 96)
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(272, 96, 32, 32, "×")
|
||||
self.contents.draw_text(308, 96, 24, 32, @number.to_s, 2)
|
||||
self.cursor_rect.set(304, 96, 32, 32)
|
||||
# Draw total price and currency units
|
||||
domination = $data_system.words.gold
|
||||
cx = contents.text_size(domination).width
|
||||
total_price = @price * @number
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(4, 160, 328-cx-2, 32, total_price.to_s, 2)
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(332-cx, 160, cx, 32, domination, 2)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Frame Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update
|
||||
super
|
||||
if self.active
|
||||
# Cursor right (+1)
|
||||
if Input.repeat?(Input::RIGHT) and @number < @max
|
||||
$game_system.se_play($data_system.cursor_se)
|
||||
@number += 1
|
||||
refresh
|
||||
end
|
||||
# Cursor left (-1)
|
||||
if Input.repeat?(Input::LEFT) and @number > 1
|
||||
$game_system.se_play($data_system.cursor_se)
|
||||
@number -= 1
|
||||
refresh
|
||||
end
|
||||
# Cursdr up (+10)
|
||||
if Input.repeat?(Input::UP) and @number < @max
|
||||
$game_system.se_play($data_system.cursor_se)
|
||||
@number = [@number + 10, @max].min
|
||||
refresh
|
||||
end
|
||||
# Cursor down (-10)
|
||||
if Input.repeat?(Input::DOWN) and @number > 1
|
||||
$game_system.se_play($data_system.cursor_se)
|
||||
@number = [@number - 10, 1].max
|
||||
refresh
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_ShopSell
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays items in possession for selling on the shop screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_ShopSell < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 128, 640, 352)
|
||||
@column_max = 2
|
||||
refresh
|
||||
self.index = 0
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Getting Items
|
||||
#--------------------------------------------------------------------------
|
||||
def item
|
||||
return @data[self.index]
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
if self.contents != nil
|
||||
self.contents.dispose
|
||||
self.contents = nil
|
||||
end
|
||||
@data = []
|
||||
for i in 1...$data_items.size
|
||||
if $game_party.item_number(i) > 0
|
||||
@data.push($data_items[i])
|
||||
end
|
||||
end
|
||||
for i in 1...$data_weapons.size
|
||||
if $game_party.weapon_number(i) > 0
|
||||
@data.push($data_weapons[i])
|
||||
end
|
||||
end
|
||||
for i in 1...$data_armors.size
|
||||
if $game_party.armor_number(i) > 0
|
||||
@data.push($data_armors[i])
|
||||
end
|
||||
end
|
||||
# If item count is not 0, make a bitmap and draw all items
|
||||
@item_max = @data.size
|
||||
if @item_max > 0
|
||||
self.contents = Bitmap.new(width - 32, row_max * 32)
|
||||
for i in 0...@item_max
|
||||
draw_item(i)
|
||||
end
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Draw Item
|
||||
# index : item number
|
||||
#--------------------------------------------------------------------------
|
||||
def draw_item(index)
|
||||
item = @data[index]
|
||||
case item
|
||||
when RPG::Item
|
||||
number = $game_party.item_number(item.id)
|
||||
when RPG::Weapon
|
||||
number = $game_party.weapon_number(item.id)
|
||||
when RPG::Armor
|
||||
number = $game_party.armor_number(item.id)
|
||||
end
|
||||
# If items are sellable, set to valid text color. If not, set to invalid
|
||||
# text color.
|
||||
if item.price > 0
|
||||
self.contents.font.color = normal_color
|
||||
else
|
||||
self.contents.font.color = disabled_color
|
||||
end
|
||||
x = 4 + index % 2 * (288 + 32)
|
||||
y = index / 2 * 32
|
||||
rect = Rect.new(x, y, self.width / @column_max - 32, 32)
|
||||
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
|
||||
bitmap = RPG::Cache.icon(item.icon_name)
|
||||
opacity = self.contents.font.color == normal_color ? 255 : 128
|
||||
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
|
||||
self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
|
||||
self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
|
||||
self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Help Text Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_help
|
||||
@help_window.set_text(self.item == nil ? "" : self.item.description)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_ShopStatus
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays number of items in possession and the actor's equipment
|
||||
# on the shop screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_ShopStatus < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(368, 128, 272, 352)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@item = nil
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
if @item == nil
|
||||
return
|
||||
end
|
||||
case @item
|
||||
when RPG::Item
|
||||
number = $game_party.item_number(@item.id)
|
||||
when RPG::Weapon
|
||||
number = $game_party.weapon_number(@item.id)
|
||||
when RPG::Armor
|
||||
number = $game_party.armor_number(@item.id)
|
||||
end
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(4, 0, 200, 32, "number in possession")
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(204, 0, 32, 32, number.to_s, 2)
|
||||
if @item.is_a?(RPG::Item)
|
||||
return
|
||||
end
|
||||
# Equipment adding information
|
||||
for i in 0...$game_party.actors.size
|
||||
# Get actor
|
||||
actor = $game_party.actors[i]
|
||||
# If equippable, then set to normal text color. If not, set to
|
||||
# invalid text color.
|
||||
if actor.equippable?(@item)
|
||||
self.contents.font.color = normal_color
|
||||
else
|
||||
self.contents.font.color = disabled_color
|
||||
end
|
||||
# Draw actor's name
|
||||
self.contents.draw_text(4, 64 + 64 * i, 120, 32, actor.name)
|
||||
# Get current equipment
|
||||
if @item.is_a?(RPG::Weapon)
|
||||
item1 = $data_weapons[actor.weapon_id]
|
||||
elsif @item.kind == 0
|
||||
item1 = $data_armors[actor.armor1_id]
|
||||
elsif @item.kind == 1
|
||||
item1 = $data_armors[actor.armor2_id]
|
||||
elsif @item.kind == 2
|
||||
item1 = $data_armors[actor.armor3_id]
|
||||
else
|
||||
item1 = $data_armors[actor.armor4_id]
|
||||
end
|
||||
# If equippable
|
||||
if actor.equippable?(@item)
|
||||
# If weapon
|
||||
if @item.is_a?(RPG::Weapon)
|
||||
atk1 = item1 != nil ? item1.atk : 0
|
||||
atk2 = @item != nil ? @item.atk : 0
|
||||
change = atk2 - atk1
|
||||
end
|
||||
# If armor
|
||||
if @item.is_a?(RPG::Armor)
|
||||
pdef1 = item1 != nil ? item1.pdef : 0
|
||||
mdef1 = item1 != nil ? item1.mdef : 0
|
||||
pdef2 = @item != nil ? @item.pdef : 0
|
||||
mdef2 = @item != nil ? @item.mdef : 0
|
||||
change = pdef2 - pdef1 + mdef2 - mdef1
|
||||
end
|
||||
# Draw parameter change values
|
||||
self.contents.draw_text(124, 64 + 64 * i, 112, 32,
|
||||
sprintf("%+d", change), 2)
|
||||
end
|
||||
# Draw item
|
||||
if item1 != nil
|
||||
x = 4
|
||||
y = 64 + 64 * i + 32
|
||||
bitmap = RPG::Cache.icon(item1.icon_name)
|
||||
opacity = self.contents.font.color == normal_color ? 255 : 128
|
||||
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
|
||||
self.contents.draw_text(x + 28, y, 212, 32, item1.name)
|
||||
end
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Set Item
|
||||
# item : new item
|
||||
#--------------------------------------------------------------------------
|
||||
def item=(item)
|
||||
if @item != item
|
||||
@item = item
|
||||
refresh
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_Status
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays full status specs on the status screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_Status < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
# actor : actor
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize(actor)
|
||||
super(0, 0, Graphics.width, Graphics.height)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
@actor = actor
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
draw_actor_graphic(@actor, 40, 112)
|
||||
draw_actor_name(@actor, 4, 0)
|
||||
draw_actor_class(@actor, 4 + 144, 0)
|
||||
draw_actor_level(@actor, 96, 32)
|
||||
draw_actor_state(@actor, 96, 64)
|
||||
draw_actor_hp(@actor, 96, 112, 172)
|
||||
draw_actor_sp(@actor, 96, 144, 172)
|
||||
draw_actor_parameter(@actor, 96, 192, 0)
|
||||
draw_actor_parameter(@actor, 96, 224, 1)
|
||||
draw_actor_parameter(@actor, 96, 256, 2)
|
||||
draw_actor_parameter(@actor, 96, 304, 3)
|
||||
draw_actor_parameter(@actor, 96, 336, 4)
|
||||
draw_actor_parameter(@actor, 96, 368, 5)
|
||||
draw_actor_parameter(@actor, 96, 400, 6)
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(320, 48, 80, 32, "EXP")
|
||||
self.contents.draw_text(320, 80, 80, 32, "NEXT")
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(320 + 80, 48, 84, 32, @actor.exp_s, 2)
|
||||
self.contents.draw_text(320 + 80, 80, 84, 32, @actor.next_rest_exp_s, 2)
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(320, 160, 96, 32, "equipment")
|
||||
draw_item_name($data_weapons[@actor.weapon_id], 320 + 16, 208)
|
||||
draw_item_name($data_armors[@actor.armor1_id], 320 + 16, 256)
|
||||
draw_item_name($data_armors[@actor.armor2_id], 320 + 16, 304)
|
||||
draw_item_name($data_armors[@actor.armor3_id], 320 + 16, 352)
|
||||
draw_item_name($data_armors[@actor.armor4_id], 320 + 16, 400)
|
||||
end
|
||||
def dummy
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(320, 112, 96, 32, $data_system.words.weapon)
|
||||
self.contents.draw_text(320, 176, 96, 32, $data_system.words.armor1)
|
||||
self.contents.draw_text(320, 240, 96, 32, $data_system.words.armor2)
|
||||
self.contents.draw_text(320, 304, 96, 32, $data_system.words.armor3)
|
||||
self.contents.draw_text(320, 368, 96, 32, $data_system.words.armor4)
|
||||
draw_item_name($data_weapons[@actor.weapon_id], 320 + 24, 144)
|
||||
draw_item_name($data_armors[@actor.armor1_id], 320 + 24, 208)
|
||||
draw_item_name($data_armors[@actor.armor2_id], 320 + 24, 272)
|
||||
draw_item_name($data_armors[@actor.armor3_id], 320 + 24, 336)
|
||||
draw_item_name($data_armors[@actor.armor4_id], 320 + 24, 400)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,26 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_Steps
|
||||
#------------------------------------------------------------------------------
|
||||
# This window displays step count on the menu screen.
|
||||
#==============================================================================
|
||||
|
||||
class Window_Steps < Window_Base
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 0, 160, 96)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
self.contents.font.color = system_color
|
||||
self.contents.draw_text(4, 0, 120, 32, "Step Count")
|
||||
self.contents.font.color = normal_color
|
||||
self.contents.draw_text(4, 32, 120, 32, $game_party.steps.to_s, 2)
|
||||
end
|
||||
end
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
#==============================================================================
|
||||
# ** Window_Target
|
||||
#------------------------------------------------------------------------------
|
||||
# This window selects a use target for the actor on item and skill screens.
|
||||
#==============================================================================
|
||||
|
||||
class Window_Target < Window_Selectable
|
||||
#--------------------------------------------------------------------------
|
||||
# * Object Initialization
|
||||
#--------------------------------------------------------------------------
|
||||
def initialize
|
||||
super(0, 0, 336, 480)
|
||||
self.contents = Bitmap.new(width - 32, height - 32)
|
||||
self.z += 10
|
||||
@item_max = $game_party.actors.size
|
||||
refresh
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Refresh
|
||||
#--------------------------------------------------------------------------
|
||||
def refresh
|
||||
self.contents.clear
|
||||
for i in 0...$game_party.actors.size
|
||||
x = 4
|
||||
y = i * 116
|
||||
actor = $game_party.actors[i]
|
||||
draw_actor_name(actor, x, y)
|
||||
draw_actor_class(actor, x + 144, y)
|
||||
draw_actor_level(actor, x + 8, y + 32)
|
||||
draw_actor_state(actor, x + 8, y + 64)
|
||||
draw_actor_hp(actor, x + 152, y + 32)
|
||||
draw_actor_sp(actor, x + 152, y + 64)
|
||||
end
|
||||
end
|
||||
#--------------------------------------------------------------------------
|
||||
# * Cursor Rectangle Update
|
||||
#--------------------------------------------------------------------------
|
||||
def update_cursor_rect
|
||||
# Cursor position -1 = all choices, -2 or lower = independent choice
|
||||
# (meaning the user's own choice)
|
||||
if @index <= -2
|
||||
self.cursor_rect.set(0, (@index + 10) * 116, self.width - 32, 96)
|
||||
elsif @index == -1
|
||||
self.cursor_rect.set(0, 0, self.width - 32, @item_max * 116 - 20)
|
||||
else
|
||||
self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -13,7 +13,6 @@ Game_Battler_2
|
|||
Game_Battler_3
|
||||
Game_BattleAction
|
||||
Game_Actor
|
||||
Game_Enemy
|
||||
Game_Actors
|
||||
Game_Party
|
||||
Game_Map
|
||||
|
|
@ -31,7 +30,6 @@ Game_FastTravel
|
|||
Settings
|
||||
|
||||
Sprite_Character
|
||||
Sprite_Battler
|
||||
Sprite_Picture
|
||||
Sprite_Timer
|
||||
Sprite_Light
|
||||
|
|
@ -44,32 +42,13 @@ FastTravel
|
|||
|
||||
Window_Base
|
||||
Window_Selectable
|
||||
Window_Command
|
||||
Window_Help
|
||||
Window_Gold
|
||||
Window_PlayTime
|
||||
Window_Steps
|
||||
Window_MenuStatus
|
||||
Window_Item
|
||||
Window_Target
|
||||
Window_EquipLeft
|
||||
Window_EquipRight
|
||||
Window_EquipItem
|
||||
Window_Status
|
||||
Window_SaveFile
|
||||
Window_Settings
|
||||
Window_ShopCommand
|
||||
Window_ShopBuy
|
||||
Window_ShopSell
|
||||
Window_ShopNumber
|
||||
Window_ShopStatus
|
||||
Window_NameEdit
|
||||
Window_NameInput
|
||||
Window_InputNumber
|
||||
Window_Message
|
||||
Window_PartyCommand
|
||||
Window_BattleStatus
|
||||
Window_BattleResult
|
||||
Window_DebugLeft
|
||||
Window_DebugRight
|
||||
Window_MainMenu
|
||||
|
|
@ -84,15 +63,6 @@ Interpreter_7
|
|||
|
||||
Scene_Title
|
||||
Scene_Map
|
||||
Scene_Menu
|
||||
Scene_Item
|
||||
Scene_Skill
|
||||
Scene_Equip
|
||||
Scene_Status
|
||||
Scene_File
|
||||
Scene_Save
|
||||
Scene_Load
|
||||
Scene_End
|
||||
Scene_Name
|
||||
Scene_Debug
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue