如何在战斗中整队

hcm · 发表于 2012-3-28 14:43:40

本帖最后由 hcm 于 2012-4-7 12:37 编辑

RT，如何在战斗中更改战斗序列（包括替补队员），因为即使队员总数很多，场上的死光也就输了，
但一次出场一大堆人总觉得怪怪的，一般都是3-4个的。

消失的三千 · 发表于 2012-3-28 16:28:42

目前没发现这样的脚本，于是写了一个~

class Window_PartyCommand < Window_Command
def make_command_list
add_command(Vocab::fight, :fight)
add_command("队伍", :party)
add_command(Vocab::escape, :escape, BattleManager.can_escape?)
end
end
class Window_BattleParty < Window_Selectable
attr_reader :pending_index
def initialize
super(64, 0, 416, window_height)
refresh
self.openness = 0
@pending_index = -1
end
def window_height
$game_party.members.size * line_height + standard_padding * 2
end
def item_max
$game_party.members.size
end
def refresh
contents.clear
draw_all_items
end
def draw_item(index)
actor = $game_party.battle_members[index]
draw_item_background(index)
draw_basic_area(basic_area_rect(index), actor)
draw_gauge_area(gauge_area_rect(index), actor)
end
def draw_item_background(index)
if index == @pending_index
contents.fill_rect(item_rect(index), pending_color)
end
end
def basic_area_rect(index)
rect = item_rect_for_text(index)
rect.width -= gauge_area_width + 10
rect
end
def gauge_area_rect(index)
rect = item_rect_for_text(index)
rect.x += rect.width - gauge_area_width
rect.width = gauge_area_width
rect
end
def gauge_area_width
return 220
end
def draw_basic_area(rect, actor)
draw_actor_name(actor, rect.x + 0, rect.y, 100)
draw_actor_icons(actor, rect.x + 104, rect.y, rect.width - 104)
end
def draw_gauge_area(rect, actor)
if $data_system.opt_display_tp
draw_gauge_area_with_tp(rect, actor)
else
draw_gauge_area_without_tp(rect, actor)
end
end
def draw_gauge_area_with_tp(rect, actor)
draw_actor_hp(actor, rect.x + 0, rect.y, 72)
draw_actor_mp(actor, rect.x + 82, rect.y, 64)
draw_actor_tp(actor, rect.x + 156, rect.y, 64)
end
def draw_gauge_area_without_tp(rect, actor)
draw_actor_hp(actor, rect.x + 0, rect.y, 134)
draw_actor_mp(actor, rect.x + 144, rect.y, 76)
end
def pending_index=(index)
last_pending_index = @pending_index
@pending_index = index
redraw_item(@pending_index)
redraw_item(last_pending_index)
end
end
class Scene_Battle < Scene_Base
alias create_party_command_window_party create_party_command_window
def create_party_command_window
create_party_command_window_party
@party_command_window.set_handler(:party, method(:command_party))
end
def command_party
@party_window = Window_BattleParty.new if @party_window == nil
@party_window.open
@party_window.activate
@party_window.index = 0
@party_window.set_handler(:ok, method(:on_formation_ok))
@party_window.set_handler(:cancel, method(:on_formation_cancel))
end
def on_formation_ok
if @party_window.pending_index >= 0
$game_party.swap_order(@party_window.index,
@party_window.pending_index)
@party_window.pending_index = -1
@party_window.redraw_item(@party_window.index)
else
@party_window.pending_index = @party_window.index
end
@party_window.activate
end
def on_formation_cancel
if @party_window.pending_index >= 0
@party_window.pending_index = -1
@party_window.activate
else
@party_window.unselect
@party_window.close
@status_window.refresh
@party_command_window.activate
end
end
end

复制代码

jezad · 发表于 2012-3-28 19:18:18

替补好像放不进

liaoking123 · 发表于 2012-3-28 19:27:26

就是不进入战斗界面战斗
怪物是做1个事件，触碰后自动打玩家，玩家按空格/回车攻击怪物，如果可以显示血魔条和伤害最好，不行就算了，，

hcm · 发表于 2012-3-28 21:52:41

消失的三千发表于 2012-3-28 16:28
目前没发现这样的脚本，于是写了一个~

这个脚本只能替换在战场上的人员，替补人员不算在内。
另外我加了禁止主角1调整序列的脚本：

class Scene_Menu < Scene_MenuBase
alias fix_num1_on_formation_ok on_formation_ok
def on_formation_ok
if @status_window.index == $game_variables[10]
Sound.play_buzzer
@status_window.activate
else
fix_num1_on_formation_ok
end
end
end

复制代码

该脚本在战斗中不起作用。

xuzhengchi · 发表于 2012-3-28 21:59:21

本帖最后由 xuzhengchi 于 2012-3-28 22:01 编辑

#==============================================================================
#
# ▼ Yanfly Engine Ace - Party System Add-On: Command Party v1.01
# -- Last Updated: 2012.01.10
# -- Level: Easy, Normal
# -- Requires: YEA - Party System v1.00+
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YEA-CommandParty"] = true
#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.01.10 - Compatibility Update: Ace Battle Engine v1.15+
# 2011.12.13 - Started Script and Finished.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# An add-on to the Yanfly Engine Ace - Party System script. This script allows
# the player to change party members during the middle of battle from the
# Party Command Window (the Fight/Escape window).
# 允许战斗中更换队员
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# Note, if you do not give your player access to the party formation menu
# available in the Party System script, this script will disable itself.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
# This script requires Yanfly Engine Ace - Party System v1.00+.
#
#==============================================================================
module YEA
module COMMAND_PARTY
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Command Party Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# This is just how the text appears visually in battle for your party and
# how often the can change party in battle. Furthermore, there's two
# switches that may be enabled or disabled to add the command to the
# game. Adjust it as you see fit. Set the switches to 0 to not use them.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
COMMAND_TEXT = "队列" # Text used for the command.
PARTY_COOLDOWN = 2 # Turns that must pass between each change.
SHOW_SWITCH = 0 # If switch is on, show command. 0 to disable.
ENABLE_SWITCH = 0 # If switch is on, enable command. 0 to disable.
end # COMMAND_PARTY
end # YEA
#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
if $imported["YEA-PartySystem"]
#==============================================================================
# ■ SceneManager
#==============================================================================
module SceneManager
#--------------------------------------------------------------------------
# new method: self.force_recall
#--------------------------------------------------------------------------
def self.force_recall(scene_class)
@scene = scene_class
end
end # SceneManager
#==============================================================================
# ■ Game_Unit
#==============================================================================
class Game_Unit
#--------------------------------------------------------------------------
# alias method: on_battle_start
#--------------------------------------------------------------------------
alias game_unit_on_battle_start_cpt on_battle_start
def on_battle_start
game_unit_on_battle_start_cpt
reset_party_cooldown
end
#--------------------------------------------------------------------------
# new method: reset_party_cooldown
#--------------------------------------------------------------------------
def reset_party_cooldown
@party_cooldown = 0
end
#--------------------------------------------------------------------------
# new method: update_party_cooldown
#--------------------------------------------------------------------------
def update_party_cooldown
reset_party_cooldown if @party_cooldown.nil?
@party_cooldown = [@party_cooldown - 1, 0].max
end
#--------------------------------------------------------------------------
# new method: battle_party_change?
#--------------------------------------------------------------------------
def battle_party_change?
switch = YEA::COMMAND_PARTY::ENABLE_SWITCH
enabled = switch <= 0 ? true : $game_switches[switch]
return false unless enabled
reset_party_cooldown if @party_cooldown.nil?
return @party_cooldown <= 0
end
#--------------------------------------------------------------------------
# new method: set_party_cooldown
#--------------------------------------------------------------------------
def set_party_cooldown
@party_cooldown = YEA::COMMAND_PARTY::PARTY_COOLDOWN
end
#--------------------------------------------------------------------------
# alias method: on_battle_end
#--------------------------------------------------------------------------
alias game_unit_on_battle_end_cpt on_battle_end
def on_battle_end
game_unit_on_battle_end_cpt
reset_party_cooldown
end
end # Game_Unit
#==============================================================================
# ■ Window_PartyCommand
#==============================================================================
class Window_PartyCommand < Window_Command
#--------------------------------------------------------------------------
# alias method: make_command_list
#--------------------------------------------------------------------------
alias window_partycommand_make_command_list_cpt make_command_list
def make_command_list
window_partycommand_make_command_list_cpt
return if $imported["YEA-BattleCommandList"]
add_party_command
end
#--------------------------------------------------------------------------
# new method: add_party_command
#--------------------------------------------------------------------------
def add_party_command
return unless YEA::PARTY::ENABLE_MENU
show = YEA::COMMAND_PARTY::SHOW_SWITCH
continue = show == 0 ? true : $game_switches[show]
continue = false if $game_party.all_members.size < 2
return unless continue
text = YEA::COMMAND_PARTY::COMMAND_TEXT
add_command(text, :party, $game_party.battle_party_change?)
end
end # Window_PartyCommand
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# alias method: create_party_command_window
#--------------------------------------------------------------------------
alias create_party_command_window_cpt create_party_command_window
def create_party_command_window
create_party_command_window_cpt
@party_command_window.set_handler(:party, method(:command_party))
end
#--------------------------------------------------------------------------
# new method: command_party
#--------------------------------------------------------------------------
def command_party
Graphics.freeze
@info_viewport.visible = false
hide_extra_gauges if $imported["YEA-BattleEngine"]
SceneManager.snapshot_for_background
previous_party = $game_party.battle_members.clone
index = @party_command_window.index
oy = @party_command_window.oy
#---
SceneManager.call(Scene_Party)
SceneManager.scene.main
SceneManager.force_recall(self)
#---
show_extra_gauges if $imported["YEA-BattleEngine"]
if previous_party != $game_party.battle_members
$game_party.make_actions
$game_party.set_party_cooldown
end
@info_viewport.visible = true
@status_window.refresh
@party_command_window.setup
@party_command_window.select(index)
@party_command_window.oy = oy
perform_transition
end
#--------------------------------------------------------------------------
# alias method: turn_end
#--------------------------------------------------------------------------
alias scene_battle_turn_end_cpt turn_end
def turn_end
scene_battle_turn_end_cpt
return if $imported["YEA-BattleEngine"]
update_party_cooldowns
end
#--------------------------------------------------------------------------
# new method: update_party_cooldowns
#--------------------------------------------------------------------------
def update_party_cooldowns
$game_party.update_party_cooldown
$game_troop.update_party_cooldown
end
end # Scene_Battle
end # $imported["YEA-PartySystem"]
#==============================================================================
#
# ▼ End of File
#
#==============================================================================

复制代码

#==============================================================================
#
# ▼ Yanfly Engine Ace - Party System v1.08
# -- Last Updated: 2012.01.23
# -- Level: Normal
# -- Requires: n/a
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YEA-PartySystem"] = true
#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.01.23 - Bug fixed: Party members are now rearranged when newly added.
# 2012.01.14 - New Feature: Maximum Battle Members Variable added.
# 2012.01.07 - Bug fixed: Error with removing members.
# 2012.01.05 - Bug fixed: Escape skill/item effects no longer counts as death.
# 2011.12.26 - Compatibility Update: New Game+
# 2011.12.17 - Updated Spriteset_Battle to have updated sprite counts.
# 2011.12.13 - Updated to provide better visual display when more than 5 pieces
# of equipment are equipped on an actor at a time.
# 2011.12.05 - Added functionality to display faces in the Party Select Window.
# - Fixed bug that doesn't refresh the caterpillar when new members
# join the party.
# 2011.12.04 - Started Script and Finished.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# RPG Maker VX Ace comes with a very nice party system. However, changing the
# maximum number of members isn't possible without the aid of a script. This
# script enables you the ability to change the maximum number of party members,
# change EXP rates, and/or open up a separate party menu (if desired). In
# addition to that, you can lock the position of actors within a party and
# require other actors to be in the active party before continuing.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# 脚本命令语句 - These commands are used with script calls.
# -----------------------------------------------------------------------------
# *IMPORTANT* These script calls require the new party menu to be enabled to
# use them. Otherwise, nothing will happen.
#
# lock_actor(x) 锁定X角色在队伍中的位置
# unlock_actor(x)
# This will lock actor x in its current position in the party if the actor is
# in the current party. The actor is unable to switch position and must remain
# in that position until the lock is removed. Use the unlock script call to
# remove the locked status. This script requires the actor to have joined and
# in the current party before the script call will work.
#
# require_actor(x) 需要X角色参战
# unrequire_actor(x)
# This will cause the party to require actor x in order to continue. If the
# actor isn't in the current party but is in the reserve party, the party menu
# will open up and prompt the player to add the required actor into the party
# before being able to continue. This script call will not function unless the
# specific actor has joined the party, whether it is in the current or reserve.
#
# call_party_menu 打开队伍菜单
# This will open up the party menu. This script call requires for the party
# menu to be enabled to use.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
#==============================================================================
module YEA
module PARTY
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - General Party Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# In this section, you can adjust the general party settings for your game
# such as the maximum amount of members and whatnot, the EXP rate for
# party members in the reserve, etc.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
MAX_BATTLE_MEMBERS = 5 # 最大参战人员. Default: 4
SPLIT_EXP = false # 平分经验？Splits EXP with more members in the party.
RESERVE_EXP_RATE = 0.50 # 休息人员的经验获得率Reserve EXP Rate. Default: 1.00
# If you wish to be able to change the maximum number of battle members
# during the middle of your game, set this constant to a variable ID. If
# that variable ID is a number greater than 0, that variable will determine
# the current maximum number of battle members. Be cautious about using
# this during battle.
MAX_MEMBERS_VARIABLE = 0 #设置游戏中改变最大参战人员的变量
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Party Menu Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# This section contains various menu settings for those who wish to use a
# menu separate for the party system. Here, adjust the menu command order,
# icons used, and other settings.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ENABLE_MENU = true # Enables party menu. Default: false
COMMANDS =[ # The order at which the menu items are shown.
# [:command, "Display"],
[ :change, "更换",],
[ :remove, "移除",],
[ :revert, "还原",],
[ :finish, "完成",],
] # Do not remove this.
COMMAND_ALIGN = 1 # 0:左对齐, 1:Center Align, 2:Right Align
# These settings here are used for the upper right window: the Party Select
# window where the player selects a member to swap out or remove.
PARTY_FONT_SIZE = 20 # Font size used for party member names.
LOCK_FIRST_ACTOR = false # Lock the first actor by default?
LOCKED_ICON = 125 # Icon used for locked members.
REQUIRED_ICON = 126 # Icon used for required members.
EMPTY_TEXT = "-Empty-" # Text used when a member isn't present.
DISPLAY_FACE = false # Display faces instead of sprites?
# These settings here are used for the lower left window: the Party List
# window where the player selects a member to replace.
REMOVE_ICON = 185 # Icon used for removing members.
REMOVE_TEXT = "-Remove-" # Text used for remove member command.
ACTOR_Y_BUFFER = 12 # Amount the actor graphic be adjusted by.
# These settings here are used for the lower right window: the Party Status
# window where info about a selected actor is shown.
NO_DATA = "- No Data -" # Text used for when no actor is shown.
IN_PARTY_COLOUR = 6 # Text colour used for in party members.
STAT_FONT_SIZE = 20 # Font size used for stats.
EQUIP_TEXT = "Equipment" # Text used to display equipment.
end # PARTY
end # YEA
#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
#==============================================================================
# ■ Icon
#==============================================================================
module Icon
#--------------------------------------------------------------------------
# self.locked_party
#--------------------------------------------------------------------------
def self.locked_party; return YEA::PARTY::LOCKED_ICON; end
#--------------------------------------------------------------------------
# self.required_party
#--------------------------------------------------------------------------
def self.required_party; return YEA::PARTY::REQUIRED_ICON; end
#--------------------------------------------------------------------------
# self.remove_party
#--------------------------------------------------------------------------
def self.remove_party; return YEA::PARTY::REMOVE_ICON; end
end # Icon
#==============================================================================
# ■ Variable
#==============================================================================
module Variable
#--------------------------------------------------------------------------
# self.max_battle_members
#--------------------------------------------------------------------------
def self.max_battle_members
default = YEA::PARTY::MAX_BATTLE_MEMBERS
return default if YEA::PARTY::MAX_MEMBERS_VARIABLE <= 0
return default if $game_variables[YEA::PARTY::MAX_MEMBERS_VARIABLE] <= 0
return $game_variables[YEA::PARTY::MAX_MEMBERS_VARIABLE]
end
end # Variable
#==============================================================================
# ■ Numeric
#==============================================================================
class Numeric
#--------------------------------------------------------------------------
# new method: group_digits
#--------------------------------------------------------------------------
unless $imported["YEA-CoreEngine"]
def group; return self.to_s; end
end # $imported["YEA-CoreEngine"]
end # Numeric
#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :locked
attr_accessor :required
#--------------------------------------------------------------------------
# alias method: setup
#--------------------------------------------------------------------------
alias game_actor_setup_ps setup
def setup(actor_id)
game_actor_setup_ps(actor_id)
@locked = false
@required = false
end
#--------------------------------------------------------------------------
# overwrite method: final_exp_rate
#--------------------------------------------------------------------------
def final_exp_rate
n = exr * (battle_member? ? 1 : reserve_members_exp_rate)
if $game_party.in_battle
n /= [$game_party.battle_members.size, 1].max if YEA::PARTY::SPLIT_EXP
end
return n
end
#--------------------------------------------------------------------------
# overwrite method: reserve_members_exp_rate
#--------------------------------------------------------------------------
def reserve_members_exp_rate
$data_system.opt_extra_exp ? YEA::PARTY::RESERVE_EXP_RATE : 0
end
end # Game_Actor
#==============================================================================
# ■ Game_Party
#==============================================================================
class Game_Party < Game_Unit
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :battle_members_array
#--------------------------------------------------------------------------
# alias method: initialize
#--------------------------------------------------------------------------
alias game_party_initialize_ps initialize
def initialize
game_party_initialize_ps
@battle_members_array = nil
end
#--------------------------------------------------------------------------
# overwrite method: max_battle_members
#--------------------------------------------------------------------------
def max_battle_members; return Variable.max_battle_members; end
#--------------------------------------------------------------------------
# alias method: setup_starting_members
#--------------------------------------------------------------------------
alias setup_starting_members_ps setup_starting_members
def setup_starting_members
setup_starting_members_ps
initialize_battle_members
return unless YEA::PARTY::LOCK_FIRST_ACTOR
return if members[0].nil?
members[0].locked = true
end
#--------------------------------------------------------------------------
# alias method: setup_battle_test_members
#--------------------------------------------------------------------------
alias setup_battle_test_members_ps setup_battle_test_members
def setup_battle_test_members
setup_battle_test_members_ps
return unless YEA::PARTY::LOCK_FIRST_ACTOR
return if members[0].nil?
members[0].locked = true
end
#--------------------------------------------------------------------------
# overwrite method: battle_members
#--------------------------------------------------------------------------
def battle_members
initialize_battle_members if initialize_battle_members?
array = []
for actor_id in @battle_members_array
break if array.size > max_battle_members
next if actor_id.nil?
next if $game_actors[actor_id].nil?
next unless $game_actors[actor_id].exist?
array.push($game_actors[actor_id])
end
return array
end
#--------------------------------------------------------------------------
# new method: initialize_battle_members?
#--------------------------------------------------------------------------
def initialize_battle_members?
return true if @battle_members_array.nil?
return @battle_members_array.size != max_battle_members
end
#--------------------------------------------------------------------------
# new method: initialize_battle_members
#--------------------------------------------------------------------------
def initialize_battle_members
@battle_members_array = []
for i in 0...max_battle_members
@battle_members_array.push(@actors[i]) unless @actors[i].nil?
@battle_members_array.push(0) if @actors[i].nil?
end
$game_player.refresh
end
#--------------------------------------------------------------------------
# alias method: add_actor
#--------------------------------------------------------------------------
alias game_party_add_actor_ps add_actor
def add_actor(actor_id)
game_party_add_actor_ps(actor_id)
return if @battle_members_array.include?(actor_id)
return unless @battle_members_array.include?(0)
index = @battle_members_array.index(0)
@battle_members_array[index] = actor_id
$game_player.refresh
$game_map.need_refresh = true
rearrange_actors
end
#--------------------------------------------------------------------------
# alias method: remove_actor
#--------------------------------------------------------------------------
alias game_party_remove_actor_ps remove_actor
def remove_actor(actor_id)
game_party_remove_actor_ps(actor_id)
return unless @battle_members_array.include?(actor_id)
index = @battle_members_array.index(actor_id)
@battle_members_array[index] = 0
$game_player.refresh
$game_map.need_refresh = true
rearrange_actors
end
#--------------------------------------------------------------------------
# new method: rearrange_actors
#--------------------------------------------------------------------------
def rearrange_actors
initialize_battle_members if @battle_members_array.nil?
array = []
for actor_id in @battle_members_array
next if [0, nil].include?(actor_id)
next if $game_actors[actor_id].nil?
array.push(actor_id)
end
for actor_id in @actors
next if array.include?(actor_id)
next if $game_actors[actor_id].nil?
array.push(actor_id)
end
@actors = array
end
end # Game_Party
#==============================================================================
# ■ Game_Interpreter
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# new method: lock_actor
#--------------------------------------------------------------------------
def lock_actor(actor_id)
return unless YEA::PARTY::ENABLE_MENU
actor = $game_actors[actor_id]
return unless $game_party.battle_members.include?(actor.id)
actor.locked = true
end
#--------------------------------------------------------------------------
# new method: unlock_actor
#--------------------------------------------------------------------------
def unlock_actor(actor_id)
return unless YEA::PARTY::ENABLE_MENU
actor = $game_actors[actor_id]
return unless $game_party.battle_members.include?(actor.id)
actor.locked = false
end
#--------------------------------------------------------------------------
# new method: require_actor
#--------------------------------------------------------------------------
def require_actor(actor_id)
return unless YEA::PARTY::ENABLE_MENU
return if $game_system.formation_disabled
actor = $game_actors[actor_id]
return unless $game_party.all_members.include?(actor)
actor.required = true
call_party_menu unless $game_party.battle_members.include?(actor)
end
#--------------------------------------------------------------------------
# new method: unrequire_actor
#--------------------------------------------------------------------------
def unrequire_actor(actor_id)
return unless YEA::PARTY::ENABLE_MENU
return if $game_system.formation_disabled
actor = $game_actors[actor_id]
return unless $game_party.all_members.include?(actor)
actor.required = false
call_party_menu unless $game_party.battle_members.include?(actor)
end
#--------------------------------------------------------------------------
# new method: call_party_menu
#--------------------------------------------------------------------------
def call_party_menu
return unless YEA::PARTY::ENABLE_MENU
return if $game_system.formation_disabled
SceneManager.call(Scene_Party)
end
end # Game_Interpreter
#==============================================================================
# ■ Spriteset_Battle
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# overwrite method: create_actors
#--------------------------------------------------------------------------
def create_actors
total = $game_party.max_battle_members
@actor_sprites = Array.new(total) { Sprite_Battler.new(@viewport1) }
end
end # Spriteset_Battle
#==============================================================================
# ■ Window_PartyMenuCommand
#==============================================================================
class Window_PartyMenuCommand < Window_Command
#--------------------------------------------------------------------------
# window_width
#--------------------------------------------------------------------------
def window_width; return 160; end
#--------------------------------------------------------------------------
# visible_line_number
#--------------------------------------------------------------------------
def visible_line_number; 4; end
#--------------------------------------------------------------------------
# alignment
#--------------------------------------------------------------------------
def alignment
return Menu.command_window_align if $imported["YEA-AceMenuEngine"]
return YEA::PARTY::COMMAND_ALIGN
end
#--------------------------------------------------------------------------
# scene
#--------------------------------------------------------------------------
def scene; return SceneManager.scene; end
#--------------------------------------------------------------------------
# make_command_list
#--------------------------------------------------------------------------
def make_command_list
for command in YEA::PARTY::COMMANDS
case command[0]
when :change, :remove, :revert
add_command(command[1], command[0])
when :finish
add_command(command[1], command[0], enable_cancel?)
else; next
end
end
end
#--------------------------------------------------------------------------
# process_cancel
#--------------------------------------------------------------------------
def process_cancel
unless enable_cancel?
Sound.play_buzzer
return
end
super
end
#--------------------------------------------------------------------------
# in_party?
#--------------------------------------------------------------------------
def in_party?(actor)
return $game_party.battle_members.include?(actor)
end
#--------------------------------------------------------------------------
# enable_cancel?
#--------------------------------------------------------------------------
def enable_cancel?
return false if $game_party.battle_members.size <= 0
for actor in $game_party.all_members
next if in_party?(actor)
return false if actor.required
return false if actor.locked
end
return true
end
end # Window_PartyMenuCommand
#==============================================================================
# ■ Window_PartySelect
#==============================================================================
class Window_PartySelect < Window_Selectable
#--------------------------------------------------------------------------
# initialize
#-------------------------------------------------------------------------
def initialize(command_window)
@command_window = command_window
super(160, 0, window_width, fitting_height(visible_line_number))
select(0)
deactivate
refresh
end
#--------------------------------------------------------------------------
# col_max
#--------------------------------------------------------------------------
def col_max; return $game_party.max_battle_members; end
#--------------------------------------------------------------------------
# item_max
#--------------------------------------------------------------------------
def item_max; return $game_party.max_battle_members; end
#--------------------------------------------------------------------------
# window_width
#--------------------------------------------------------------------------
def window_width; return Graphics.width - 160; end
#--------------------------------------------------------------------------
# visible_line_number
#--------------------------------------------------------------------------
def visible_line_number; 4; end
#--------------------------------------------------------------------------
# item_rect
#--------------------------------------------------------------------------
def item_rect(index)
rect = Rect.new
rect.width = contents.width / item_max
rect.height = contents.height
rect.x = index * rect.width
rect.y = 0
return rect
end
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
make_item_list
create_contents
draw_all_items
end
#--------------------------------------------------------------------------
# make_item_list
#--------------------------------------------------------------------------
def make_item_list
@data = $game_party.battle_members_array.clone
end
#--------------------------------------------------------------------------
# draw_item
#--------------------------------------------------------------------------
def draw_item(index)
actor = $game_actors[@data[index]]
rect = item_rect(index)
if actor.nil?
draw_empty(rect.clone)
return
end
dx = rect.width / 2
dy = rect.height - 16
draw_actor_face(actor, rect.x, rect.y) if display_face?
draw_actor_graphic(actor, rect.x + dx, rect.y + dy) unless display_face?
draw_actor_name(actor, rect)
draw_locked_icon(actor, rect)
draw_required_icon(actor, rect)
end
#--------------------------------------------------------------------------
# display_face?
#--------------------------------------------------------------------------
def display_face?
return YEA::PARTY::DISPLAY_FACE
end
#--------------------------------------------------------------------------
# draw_empty
#--------------------------------------------------------------------------
def draw_empty(rect)
colour = Color.new(0, 0, 0, translucent_alpha/2)
rect.x += 2
rect.y += 2
rect.width -= 4
rect.height -= 4
contents.fill_rect(rect, colour)
reset_font_settings
change_color(system_color)
text = YEA::PARTY::EMPTY_TEXT
draw_text(rect, text, 1)
reset_font_settings
end
#--------------------------------------------------------------------------
# draw_actor_name
#--------------------------------------------------------------------------
def draw_actor_name(actor, rect)
contents.font.size = YEA::PARTY::PARTY_FONT_SIZE
change_color(normal_color, actor.exist?)
draw_text(rect.x+4, rect.y, rect.width-8, line_height, actor.name, 1)
end
#--------------------------------------------------------------------------
# draw_face
#--------------------------------------------------------------------------
def draw_face(face_name, face_index, dx, dy, enabled = true)
bitmap = Cache.face(face_name)
dw = [96, item_rect(0).width-4].min
rect = Rect.new(face_index % 4 * 96, face_index / 4 * 96, dw, 92)
contents.blt(dx+2, dy+2, bitmap, rect, enabled ? 255 : translucent_alpha)
bitmap.dispose
end
#--------------------------------------------------------------------------
# draw_locked_icon
#--------------------------------------------------------------------------
def draw_locked_icon(actor, rect)
return unless actor_locked?(actor)
draw_icon(Icon.locked_party, rect.x+rect.width-26, rect.height - 26)
end
#--------------------------------------------------------------------------
# draw_required_icon
#--------------------------------------------------------------------------
def draw_required_icon(actor, rect)
return if actor_locked?(actor)
return unless actor_required?(actor)
draw_icon(Icon.required_party, rect.x+rect.width-26, rect.height - 26)
end
#--------------------------------------------------------------------------
# actor_locked?
#--------------------------------------------------------------------------
def actor_locked?(actor); return actor.locked; end
#--------------------------------------------------------------------------
# actor_required?
#--------------------------------------------------------------------------
def actor_required?(actor)
return false if actor.locked
return actor.required
end
#--------------------------------------------------------------------------
# current_item_enabled?
#--------------------------------------------------------------------------
def current_item_enabled?; enable?(@data[index]); end
#--------------------------------------------------------------------------
# enable?
#--------------------------------------------------------------------------
def enable?(item)
case @command_window.current_symbol
when :change
return true if item.nil?
return true if item == 0
when :remove
return false if item.nil?
return false if item == 0
end
actor = $game_actors[item]
return false if actor.locked
return false if actor.required
return true
end
#--------------------------------------------------------------------------
# process_handling
#--------------------------------------------------------------------------
def process_handling
return unless open? && active
return process_ok if ok_enabled? && Input.trigger?(:C)
return process_cancel if cancel_enabled? && Input.trigger?(:B)
return process_pagedown if handle?(:pagedown) && Input.repeat?(:R)
return process_pageup if handle?(:pageup) && Input.repeat?(:L)
end
#--------------------------------------------------------------------------
# cur_actor
#--------------------------------------------------------------------------
def cur_actor
actor_id = @data[index]
return $game_actors[actor_id]
end
#--------------------------------------------------------------------------
# prev_actor
#--------------------------------------------------------------------------
def prev_actor
id = index == 0 ? @data.size - 1 : index - 1
actor_id = @data[id]
return $game_actors[actor_id]
end
#--------------------------------------------------------------------------
# next_actor
#--------------------------------------------------------------------------
def next_actor
id = index == @data.size - 1 ? 0 : index + 1
actor_id = @data[id]
return $game_actors[actor_id]
end
#--------------------------------------------------------------------------
# process_pageup
#--------------------------------------------------------------------------
def process_pageup
allow = true
allow = false if !prev_actor.nil? && prev_actor.locked
allow = false if !cur_actor.nil? && cur_actor.locked
Sound.play_buzzer unless allow
if allow
super
activate
select(index == 0 ? @data.size - 1 : index - 1)
end
end
#--------------------------------------------------------------------------
# process_pagedown
#--------------------------------------------------------------------------
def process_pagedown
allow = true
allow = false if !next_actor.nil? && next_actor.locked
allow = false if !cur_actor.nil? && cur_actor.locked
Sound.play_buzzer unless allow
if allow
super
activate
select(index == @data.size - 1 ? 0 : index + 1)
end
end
#--------------------------------------------------------------------------
# item
#--------------------------------------------------------------------------
def item; return @data[index]; end
end # Window_PartySelect
#==============================================================================
# ■ Window_PartyList
#==============================================================================
class Window_PartyList < Window_Selectable
#--------------------------------------------------------------------------
# initialize
#-------------------------------------------------------------------------
def initialize(party_window)
super(0, fitting_height(4), window_width, window_height)
@party_window = party_window
select(1)
deactivate
refresh
end
#--------------------------------------------------------------------------
# window_width
#--------------------------------------------------------------------------
def window_width; return 200; end
#--------------------------------------------------------------------------
# window_height
#--------------------------------------------------------------------------
def window_height; return Graphics.height - fitting_height(4); end
#--------------------------------------------------------------------------
# item_max
#--------------------------------------------------------------------------
def item_max; return @data ? @data.size : 1; end
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
make_item_list
create_contents
draw_all_items
end
#--------------------------------------------------------------------------
# make_item_list
#--------------------------------------------------------------------------
def make_item_list
@data = [0]
for member in $game_party.all_members
next if member.nil?
@data.push(member.id)
end
@data.push(0)
end
#--------------------------------------------------------------------------
# draw_item
#--------------------------------------------------------------------------
def draw_item(index)
clear_item(index)
rect = item_rect(index)
if @data[index] == 0
draw_remove(rect)
return
end
actor = $game_actors[@data[index]]
draw_actor(actor, rect)
draw_actor_locked(actor, rect)
draw_actor_required(actor, rect)
end
#--------------------------------------------------------------------------
# draw_remove
#--------------------------------------------------------------------------
def draw_remove(rect)
reset_font_settings
draw_icon(Icon.remove_party, rect.x+4, rect.y)
text = YEA::PARTY::REMOVE_TEXT
draw_text(rect.x+32, rect.y, rect.width-32, line_height, text)
end
#--------------------------------------------------------------------------
# draw_actor
#--------------------------------------------------------------------------
def draw_actor(actor, rect)
buffer = YEA::PARTY::ACTOR_Y_BUFFER
draw_actor_graphic(actor, rect.x + 16, rect.y + rect.height + buffer)
text = actor.name
change_color(list_colour(actor), enabled?(actor))
draw_text(rect.x+32, rect.y, rect.width-32, line_height, text)
end
#--------------------------------------------------------------------------
# list_colour
#--------------------------------------------------------------------------
def list_colour(actor)
return text_color(YEA::PARTY::IN_PARTY_COLOUR) if in_party?(actor)
return normal_color
end
#--------------------------------------------------------------------------
# draw_actor_locked
#--------------------------------------------------------------------------
def draw_actor_locked(actor, rect)
return unless actor.locked
draw_icon(Icon.locked_party, rect.width-24, rect.y)
end
#--------------------------------------------------------------------------
# draw_actor_required
#--------------------------------------------------------------------------
def draw_actor_required(actor, rect)
return if actor.locked
return unless actor.required
draw_icon(Icon.required_party, rect.width-24, rect.y)
end
#--------------------------------------------------------------------------
# enabled?
#--------------------------------------------------------------------------
def enabled?(actor)
return false if actor.locked
return false if actor.required && in_party?(actor)
return actor.exist?
end
#--------------------------------------------------------------------------
# in_party?
#--------------------------------------------------------------------------
def in_party?(actor); return $game_party.battle_members.include?(actor); end
#--------------------------------------------------------------------------
# current_item_enabled?
#--------------------------------------------------------------------------
def current_item_enabled?
actor = $game_actors[item]
replace = $game_actors[@party_window.item]
unless actor.nil?
return false if actor.locked && in_party?(actor)
return false if actor.required && in_party?(actor)
end
return true if replace.nil?
return false if replace.locked
return false if replace.required
return true if actor.nil?
return actor.exist?
end
#--------------------------------------------------------------------------
# item
#--------------------------------------------------------------------------
def item; return @data[index]; end
end # Window_PartyList
#==============================================================================
# ** Window_PartyStatus
#==============================================================================
class Window_PartyStatus < Window_Base
#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(party_window, list_window)
super(200, fitting_height(4), window_width, window_height)
@party_window = party_window
@list_window = list_window
@actor = active_actor
refresh
end
#--------------------------------------------------------------------------
# window_width
#--------------------------------------------------------------------------
def window_width; Graphics.width - 200; end
#--------------------------------------------------------------------------
# window_height
#--------------------------------------------------------------------------
def window_height; Graphics.height - fitting_height(4); end
#--------------------------------------------------------------------------
# update
#--------------------------------------------------------------------------
def update
super
refresh if @actor != active_actor
end
#--------------------------------------------------------------------------
# active_actor
#--------------------------------------------------------------------------
def active_actor
if @list_window.active
actor = @list_window.item
else
actor = @party_window.item
end
return nil if [0, nil].include?(actor)
return actor
end
#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
contents.clear
@actor = active_actor
reset_font_settings
if @actor.nil?
draw_nil_actor
return
end
actor = $game_actors[@actor]
draw_actor_face(actor, 0, 0)
draw_actor_name(actor, 108, 0)
draw_actor_class(actor, 228, 0, contents.width-232)
draw_actor_level(actor, 108, line_height)
draw_actor_icons(actor, 228, line_height, contents.width-232)
draw_actor_hp(actor, 108, line_height*2, contents.width-112)
draw_actor_mp(actor, 108, line_height*3, contents.width-112)
draw_actor_parameters(actor, 0, line_height*4 + line_height/2)
draw_equipments(actor, contents.width/2, line_height*4 + line_height/2)
end
#--------------------------------------------------------------------------
# draw_nil_actor
#--------------------------------------------------------------------------
def draw_nil_actor
colour = Color.new(0, 0, 0, translucent_alpha/2)
rect = Rect.new(0, 0, contents.width, contents.height)
contents.fill_rect(rect, colour)
change_color(system_color)
text = YEA::PARTY::NO_DATA
draw_text(rect, text, 1)
end
#--------------------------------------------------------------------------
# draw_actor_parameters
#--------------------------------------------------------------------------
def draw_actor_parameters(actor, dx, dy)
dw = contents.width/2 - 4
rect = Rect.new(dx+1, dy+1, dw - 2, line_height - 2)
contents.font.size = YEA::PARTY::STAT_FONT_SIZE
colour = Color.new(0, 0, 0, translucent_alpha/2)
array = [:atk, :def, :mat, :mdf, :agi, :luk]
cx = 4
for stat in array
case stat
when :atk
param = Vocab::param(2)
value = actor.atk.group
when :def
param = Vocab::param(3)
value = actor.def.group
when :mat
param = Vocab::param(4)
value = actor.mat.group
when :mdf
param = Vocab::param(5)
value = actor.mdf.group
when :agi
param = Vocab::param(6)
value = actor.agi.group
when :luk
param = Vocab::param(7)
value = actor.luk.group
else; next
end
contents.fill_rect(rect, colour)
change_color(system_color)
draw_text(rect.x + cx, rect.y, rect.width-cx*2, line_height, param, 0)
change_color(normal_color)
draw_text(rect.x + cx, rect.y, rect.width-cx*2, line_height, value, 2)
rect.y += line_height
end
reset_font_settings
end
#--------------------------------------------------------------------------
# draw_equipments
#--------------------------------------------------------------------------
def draw_equipments(actor, dx, dy)
text = YEA::PARTY::EQUIP_TEXT
change_color(system_color)
draw_text(dx, dy, contents.width - dx, line_height, text, 1)
dy += line_height
if actor.equips.size <= 5
actor.equips.each_with_index do |item, i|
draw_item_name(item, dx, dy + line_height * i)
end
else
orig_x = dx
actor.equips.each_with_index do |item, i|
next if item.nil?
draw_icon(item.icon_index, dx, dy)
dy += line_height if dx + 48 > contents.width
dx = dx + 48 > contents.width ? orig_x : dx + 24
end
end
end
end # Window_PartyStatus
#==============================================================================
# ■ Scene_Menu
#==============================================================================
class Scene_Menu < Scene_MenuBase
#--------------------------------------------------------------------------
# overwrite method: command_formation
#--------------------------------------------------------------------------
if YEA::PARTY::ENABLE_MENU
def command_formation
SceneManager.call(Scene_Party)
end
end # YEA::PARTY::ENABLE_MENU
end # Scene_Menu
#==============================================================================
# ■ Scene_Party
#==============================================================================
class Scene_Party < Scene_MenuBase
#--------------------------------------------------------------------------
# start
#--------------------------------------------------------------------------
def start
super
@former_party = $game_party.battle_members_array.clone
create_command_window
create_party_window
create_list_window
create_status_window
end
#--------------------------------------------------------------------------
# create_command_window
#--------------------------------------------------------------------------
def create_command_window
@command_window = Window_PartyMenuCommand.new(0, 0)
@command_window.set_handler(:change, method(:adjust_members))
@command_window.set_handler(:remove, method(:adjust_members))
@command_window.set_handler(:revert, method(:revert_party))
@command_window.set_handler(:finish, method(:return_scene))
@command_window.set_handler(:cancel, method(:return_scene))
end
#--------------------------------------------------------------------------
# create_party_window
#--------------------------------------------------------------------------
def create_party_window
@party_window = Window_PartySelect.new(@command_window)
@party_window.set_handler(:ok, method(:on_party_ok))
@party_window.set_handler(:cancel, method(:on_party_cancel))
@party_window.set_handler(:pageup, method(:on_party_pageup))
@party_window.set_handler(:pagedown, method(:on_party_pagedown))
end
#--------------------------------------------------------------------------
# create_list_window
#--------------------------------------------------------------------------
def create_list_window
@list_window = Window_PartyList.new(@party_window)
@list_window.set_handler(:ok, method(:on_list_ok))
@list_window.set_handler(:cancel, method(:on_list_cancel))
end
#--------------------------------------------------------------------------
# create_status_window
#--------------------------------------------------------------------------
def create_status_window
@status_window = Window_PartyStatus.new(@party_window, @list_window)
end
#--------------------------------------------------------------------------
# adjust_members
#--------------------------------------------------------------------------
def adjust_members
@party_window.activate
end
#--------------------------------------------------------------------------
# window_refresh
#--------------------------------------------------------------------------
def window_refresh
$game_party.rearrange_actors
@command_window.refresh
@party_window.refresh
@list_window.refresh
$game_player.refresh
$game_map.need_refresh = true
end
#--------------------------------------------------------------------------
# revert_party
#--------------------------------------------------------------------------
def revert_party
@command_window.activate
$game_party.battle_members_array = @former_party.clone
window_refresh
end
#--------------------------------------------------------------------------
# on_party_ok
#--------------------------------------------------------------------------
def on_party_ok
case @command_window.current_symbol
when :change
@list_window.activate
when :remove
index = @party_window.index
actor = $game_actors[$game_party.battle_members_array[index]]
Sound.play_equip
$game_party.battle_members_array[index] = 0
window_refresh
@party_window.activate
end
end
#--------------------------------------------------------------------------
# on_party_cancel
#--------------------------------------------------------------------------
def on_party_cancel
@command_window.activate
end
#--------------------------------------------------------------------------
# on_party_pageup
#--------------------------------------------------------------------------
def on_party_pageup
Sound.play_equip
actor_id1 = @party_window.item
actor_id2 = @party_window.prev_actor.nil? ? 0 : @party_window.prev_actor.id
max = @party_window.item_max-1
index1 = @party_window.index
index2 = @party_window.index == 0 ? max : index1-1
$game_party.battle_members_array[index1] = actor_id2
$game_party.battle_members_array[index2] = actor_id1
window_refresh
end
#--------------------------------------------------------------------------
# on_party_pagedown
#--------------------------------------------------------------------------
def on_party_pagedown
Sound.play_equip
actor_id1 = @party_window.item
actor_id2 = @party_window.next_actor.nil? ? 0 : @party_window.next_actor.id
max = @party_window.item_max-1
index1 = @party_window.index
index2 = @party_window.index == max ? 0 : index1+1
$game_party.battle_members_array[index1] = actor_id2
$game_party.battle_members_array[index2] = actor_id1
window_refresh
end
#--------------------------------------------------------------------------
# on_list_cancel
#--------------------------------------------------------------------------
def on_list_cancel
@party_window.activate
end
#--------------------------------------------------------------------------
# on_list_ok
#--------------------------------------------------------------------------
def on_list_ok
Sound.play_equip
replace = $game_actors[@party_window.item]
actor = $game_actors[@list_window.item]
index1 = @party_window.index
actor_id1 = actor.nil? ? 0 : actor.id
if actor.nil?
$game_party.battle_members_array[index1] = 0
window_refresh
@party_window.activate
return
end
actor_id2 = replace.nil? ? 0 : replace.id
if $game_party.battle_members_array.include?(actor_id1)
index2 = $game_party.battle_members_array.index(actor_id1)
$game_party.battle_members_array[index2] = actor_id2
end
$game_party.battle_members_array[index1] = actor_id1
window_refresh
@party_window.activate
end
end # Scene_Party
#==============================================================================
#
# ▼ End of File
#
#==============================================================================

复制代码

第二个是YEA的队列脚本，作为战斗更换脚本的前置脚本存在。

jezad · 发表于 2012-3-28 22:10:26

楼上这个能让所有人都上场……可是怎么换呢

hcm · 发表于 2012-3-28 22:40:39

xuzhengchi 发表于 2012-3-28 21:59
第二个是YEA的队列脚本，作为战斗更换脚本的前置脚本存在。

是不错的脚本啊，就是想问一下有没有办法禁止第一战斗序列更改，
加这套脚本后5楼的脚本失效了。

tseyik · 发表于 2012-3-28 22:42:59

本帖最后由 tseyik 于 2012-3-28 23:22 编辑

http://a1tktk.web.fc2.com/scripts_page/change_member.html
A1共通スクリプト

# ===========================================================================
# ◆ A1 Scripts ◆
# A1共通処理（RGSS2/RGSS3共用）
#
# バージョン： 4.50 (2012/01/26)
# 作者： A1
# URL　　　　　： http://a1tktk.web.fc2.com/
# ---------------------------------------------------------------------------
# 更新履歴　　：2011/11/11 Ver1.00 新規作成
# 　　　　　　：2011/12/22 Ver2.00 RGSS3用と同様の処理に変更
# 　　　　　　：2011/12/30 Ver2.10 RGSS3用メソッドを追加
# 　　　　　　：2011/12/30 Ver3.00 RGSS3用共通処理と統合
# 　　　　　　：2011/12/31 Ver3.10 マップチップサーチの仕様を変更
# 　　　　　　：2011/12/31 Ver3.10 拡張通行判定を追加
# 　　　　　　：2012/01/01 Ver3.11 クラス名の取得処理を追加
# ：2012/01/02 Ver3.20 配列を考慮したsplit処理を追加
# ：2012/01/02 Ver3.20 配列の全ての要素を整数にする処理を追加
# ：2012/01/02 Ver3.30 注釈の処理の仕様を変更
# ：2012/01/02 Ver3.40 「前のイベントコマンドの取得」を追加
# ：2012/01/03 Ver3.50 「フレーム更新」を追加
# ：2012/01/04 Ver3.60 「指定のウィンドウが開いている間ウェイト」追加
# ：2012/01/04 Ver3.70 RGSS2用処理見直し
# ：2012/01/05 Ver3.80 注釈文字列にエスケープコマンド対応
# ：2012/01/05 Ver3.80 多次元配列を考慮したsplit処理を追加
# ：2012/01/05 Ver3.80 注釈にスクリプト処理機能を追加
# ：2012/01/10 Ver3.90 文字縁取り描画を追加
# ：2012/01/11 Ver4.00 テキストビットマップのキャッシュを追加
# ：2012/01/13 Ver4.01 「タイルセットの変更」ができなくなる不具合を修正
# ：2012/01/14 Ver4.10 split処理を強化
# ：2012/01/14 Ver4.20 空白を含む注釈コマンドに対応
# ：2012/01/14 Ver4.21 split処理の不具合を修正
# ：2012/01/21 Ver4.30 メモの内容を取得する関数を追加
# ：2012/01/24 Ver4.40 メモの内容を取得する関数を追加
# ：2012/01/24 Ver4.50 メモの内容を取得する関数を追加
# ---------------------------------------------------------------------------
# 設置場所
#　　なるべく上の方
#
# 必要スクリプト
# なし
#==============================================================================
$imported = {} if $imported == nil
$imported["A1_Common_Script"] = 4.50
#==============================================================================
# ■ Kernel
#==============================================================================
module Kernel
#--------------------------------------------------------------------------
# ○ RGSSのバージョン取得
#--------------------------------------------------------------------------
def rgss_version
return 3 if defined? Graphics.play_movie
return 2 if defined? Graphics.resize_screen
return 1
end
#--------------------------------------------------------------------------
# ○ コモンスクリプトのバージョン取得
#--------------------------------------------------------------------------
def common_version
$imported["A1_Common_Script"]
end
#--------------------------------------------------------------------------
# ○ コモンスクリプトのバージョンが古い
#--------------------------------------------------------------------------
def old_common_script(script_name, version)
msgbox("#{script_name}にはA1共通スクリプトVer#{version}以上が必要です")
end
end
#==============================================================================
# ■ A1_System
#==============================================================================
module A1_System
end
#==============================================================================
# ■ A1_System::CommonModule
#==============================================================================
class A1_System::CommonModule
#--------------------------------------------------------------------------
# ○ 定数
#--------------------------------------------------------------------------
TWOBYTE_LIST = {
"　" => " ",
"＝" => "=",
"：" => ":"
}
#--------------------------------------------------------------------------
# ○ オブジェクト初期化
#--------------------------------------------------------------------------
def initialize
define_command
end
#--------------------------------------------------------------------------
# ○ 変換対象の全角文字を半角に置換
#--------------------------------------------------------------------------
def replace_twobyte(str)
for key in TWOBYTE_LIST.keys
str.gsub!(key) {TWOBYTE_LIST[key]}
end
return str
end
#--------------------------------------------------------------------------
# ○ マイナスが含まれている文字列を数値にする
#--------------------------------------------------------------------------
def minus_to_i(s)
if s[0,0] == "-"
s.gsub!("-","")
return s.to_i * -1
else
return s.to_i
end
end
#--------------------------------------------------------------------------
# ○ ミリ秒単位の現在時間
#--------------------------------------------------------------------------
def now_usec
now = Time.now
hour = now.hour * 60 * 60
min = now.min * 60
sec = now.sec
msec = (now.usec / 1000.0).round
return (hour + min + sec) * 1000 + msec
end
#--------------------------------------------------------------------------
# ○ イベントリストの作成
#--------------------------------------------------------------------------
def create_event_list(code, indent, parameters)
list = RPG::EventCommand.new
list.code = code
list.indent = indent
list.parameters = parameters
return list
end
#--------------------------------------------------------------------------
# ○ メソッド呼び出し
#--------------------------------------------------------------------------
def send_method(method_name)
return send(method_name) if respond_to?(method_name)
end
#--------------------------------------------------------------------------
# ○ オブジェクトの型を判断してStringならエンコード
#--------------------------------------------------------------------------
def encoding_string(obj)
obj.force_encoding("UTF-8") if obj.is_a?(String)
return obj
end
#--------------------------------------------------------------------------
# ○ メモの内容から必要な情報を取得
#--------------------------------------------------------------------------
def note_data(note, key)
result = []
note.each_line {|line|
next unless line =~ /<#{key}[ ]?(.*)>/
return true if $1.empty?
data = $a1_common.replace_twobyte($1).split(" ")
for st in data
result.push(st)
end
}
return false if result.empty?
return result
end
#--------------------------------------------------------------------------
# ○ メモの内容からハッシュを作成
#--------------------------------------------------------------------------
def note_data_hash(note, key, data_default = nil, default = {}, ret = {})
list = note_data_split(note, key)
return default if list.empty?
list.each {|data| ret[data[0]] = data[1] ? data[1] : data_default }
return ret
end
#--------------------------------------------------------------------------
# ○ メモの内容からカンマ区切りの多元配列を取得
#--------------------------------------------------------------------------
def note_data_split(note, key, default = [], ret = [])
data = note_data(note, key)
return default unless data.is_a?(Array)
data.each {|str| ret.push(convert_integer_from_array(split_array(str)))}
return ret
end
#--------------------------------------------------------------------------
# ○ 配列の内容から数値があれば変換
#--------------------------------------------------------------------------
def convert_integer_from_array(data, ret = [])
data.each {|str| ret.push(convert_integer(str))}
return ret
end
#--------------------------------------------------------------------------
# ○ 数値があれば変換
#--------------------------------------------------------------------------
def convert_integer(str)
return $1.to_i if str =~ /(^[-]?[0-9]+$)/
str.is_a?(Array) ? convert_integer_from_array(str) : str
end
#--------------------------------------------------------------------------
# ○ メモの内容から単項目の数値を取得
#--------------------------------------------------------------------------
def note_data_one_value(note, key, default)
data = note_data(note, key)
return data[0].to_i if data.is_a?(Array)
return default
end
#--------------------------------------------------------------------------
# ○ メモの内容から単項目を取得
#--------------------------------------------------------------------------
def note_data_one(note, key, default)
data = note_data(note, key)
return data[0] if data.is_a?(Array)
return default
end
#--------------------------------------------------------------------------
# ○ メモの内容からカンマ区切りの文字列を取得
#--------------------------------------------------------------------------
def note_data_array_str(note, key, default)
data = note_data(note, key)
return data[0].split(",") if data.is_a?(Array)
return default
end
#--------------------------------------------------------------------------
# ○ メモの内容からカンマ区切りの数値を取得
#--------------------------------------------------------------------------
def note_data_array_value(note, key, default)
data = note_data(note, key)
return default unless data.is_a?(Array)
return convert_integer_from_array(split_array(data[0]))
end
#--------------------------------------------------------------------------
# ○ カンマ区切りの文字列メモを変換
#--------------------------------------------------------------------------
def note_data_array(note, key, type, default = nil, through = true)
ret = []
default.each {|dat| ret.push(dat)} if default != nil
data = note_data(note, key)
return ret unless data.is_a?(Array)
data = data[0].split(",")
for d in data
next if ret.include?(d) if through
ret.push(d.to_i) if type.is_a?(Integer)
ret.push(d) if type.is_a?(String)
end
return ret
end
#--------------------------------------------------------------------------
# ○ ディレクトリの作成
#--------------------------------------------------------------------------
def make_directory(dir_name)
Dir::mkdir(dir_name) unless FileTest.exist?(dir_name)
end
#--------------------------------------------------------------------------
# ○ コマンドリスト
#--------------------------------------------------------------------------
def make_command(command, src = "", dect = "")
src.gsub!("/","\\")
dect.gsub!("/","\\")
cmd = "#{command} \"#{src}\" \"#{dect}\""
return cmd
end
#--------------------------------------------------------------------------
# ○ 素材の拡張子を取得
#--------------------------------------------------------------------------
def material_ext(directory, file, direct = false)
exts = []
exts = [".png",".bmp",".jpg"] if directory =~ /(.*)Graphics\/(.*)/
exts = [".mid",".ogg",".wav",".mp3",".wma"] if directory =~ /(.*)Audio(.*)/
find_file = sprintf("%s%s", directory, file) unless direct
find_file = file if direct
for ext in exts
return ext if File.exist?(sprintf("%s%s", find_file, ext))
end
return nil
end
#--------------------------------------------------------------------------
# ○ 素材が存在するかチェック
#--------------------------------------------------------------------------
def material_exist?(directory, file, direct = false)
return false if material_ext(directory, file, direct) == nil
return true
end
#--------------------------------------------------------------------------
# ○ ファイルコピー
#--------------------------------------------------------------------------
def copy_file(src, dest)
srcFile = File.open( src, "rb" )
dstFile = File.open( dest, "wb" )
dstFile.write( srcFile.read )
srcFile.close
dstFile.close
end
#--------------------------------------------------------------------------
# ○ ファイルの存在を確認してファイルコピー
#--------------------------------------------------------------------------
def material_copy(src, dest, directory)
ext = material_ext(directory, src, true)
copy_file( src + ext, dest + ext ) if ext != nil
end
#--------------------------------------------------------------------------
# ○ 配列からAudioを作成
#--------------------------------------------------------------------------
def set_audio(sound, kind)
case kind
when "BGM"; audio = RPG::BGM.new
when "BGS"; audio = RPG::BGS.new
when "ME"; audio = RPG::ME.new
when "SE"; audio = RPG::SE.new
end
audio.name = sound[0]
audio.volume = sound[1]
audio.pitch = sound[2]
return audio
end
#--------------------------------------------------------------------------
# ○ 既に準拠識別子を持っているかチェック
#--------------------------------------------------------------------------
def chk_rtp(file_name, default)
return "" if file_name =~ /^VX_.*/
return "" if file_name =~ /^XP_.*/
return "" if file_name =~ /^2000_.*/
return "" if file_name =~ /^2003_.*/
return default
end
#--------------------------------------------------------------------------
# ○ 先頭の $ を切り出す
#--------------------------------------------------------------------------
def one_character(file_name)
return file_name unless file_name[0] == "$"
tmp = file_name.clone
tmp[0] = ""
return tmp
end
#--------------------------------------------------------------------------
# ○ 配列を入れ替える
#--------------------------------------------------------------------------
def change_array(array, index1, index2)
tmp = array[index1]
array[index1] = array[index2]
array[index2] = tmp
return array
end
#--------------------------------------------------------------------------
# ○ 移動ルートの作成
#--------------------------------------------------------------------------
def create_move_route(repeat, skippable, wait, list)
move_route = RPG::MoveRoute.new
move_route.repeat = repeat
move_route.skippable = skippable
move_route.wait = wait
move_route.list = list
return move_route
end
#--------------------------------------------------------------------------
# ○ 移動ルートコマンドの作成
#--------------------------------------------------------------------------
def create_move_command(code, parameters)
list = RPG::MoveCommand.new
list.code = code
list.parameters = parameters
return list
end
#--------------------------------------------------------------------------
# ○ インタプリタ起動用リストの作成
#--------------------------------------------------------------------------
def create_list(code, indent, parameters)
list = RPG::EventCommand.new
list.code = code
list.indent = indent
list.parameters = parameters
return list
end
#--------------------------------------------------------------------------
# ○ クラス名の取得
#--------------------------------------------------------------------------
def class_name(class_instance)
return class_instance.to_s.split(":")[0].gsub("#<","")
end
#--------------------------------------------------------------------------
# ○ 配列を考慮したsplit
#--------------------------------------------------------------------------
def split_array(str)
str = convert_escape_characters(str)
ret = []
tmp_array = str.split(",")
return strip_array_str(tmp_array) unless str.include?("[")
tmp_str = ""
tmp_array.each {|s|
if char_in_str(s, "[", "]") && tmp_str.empty?
ret.push(s) unless s =~ /^\[/
ret.push([s[1...s.size-1]]) if s =~ /^\[/
else
tmp_str = "#{tmp_str}#{s},"
if char_in_str(tmp_str, "[", "]")
unless tmp_str =~ /^\[/
ret.push(tmp_str[0...tmp_str.size-1])
tmp_str = ""
else
tmp_str = tmp_str[1...tmp_str.size-2]
tmp_str = split_array(tmp_str) if tmp_str.include?("[")
tmp_str = tmp_str.split(",") if tmp_str.include?(",")
ret.push(tmp_str) if tmp_str.is_a?(Array)
ret.push([tmp_str]) if !tmp_str.is_a?(Array)
tmp_str = ""
end
end
end
}
return strip_array_str(ret)
end
#--------------------------------------------------------------------------
# ○ 配列の中の文字列の先頭と末尾の空白を除去
#--------------------------------------------------------------------------
def strip_array_str(array, ret = [])
array.each {|str| ret.push(strip_array_str(str)) if str.is_a?(Array); next if str.is_a?(Array); ret.push(str.strip) }
return ret
end
#--------------------------------------------------------------------------
# ○ 文字列の中に文字が何文字含まれているか調べて同数ならtrueを返す
#--------------------------------------------------------------------------
def char_in_str(str, c1, c2)
num1 = 0
num2 = 0
(0...str.size).each {|i| num1 += 1 if str[i] == c1; num2 += 1 if str[i] == c2 }
return num1 == num2
end
#--------------------------------------------------------------------------
# ○ 制御文字の変換
#--------------------------------------------------------------------------
def convert_escape_characters(text)
result = text.to_s.clone
result.gsub!(/\\/) { "\e" }
result.gsub!(/\e\e/) { "\\" }
result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] }
result.gsub!(/\eV\[(\d+)\]/i) { $game_variables[$1.to_i] }
result.gsub!(/\eN\[(\d+)\]/i) { actor_name($1.to_i) }
result.gsub!(/\eP\[(\d+)\]/i) { party_member_name($1.to_i) }
result.gsub!(/\eG/i) { Vocab::currency_unit }
loop { result = result.sub(/<s>(.+?)<\/s>/i) { eval($1) }; break unless $1 }
result
end
#--------------------------------------------------------------------------
# ○ アクター n 番の名前を取得
#--------------------------------------------------------------------------
def actor_name(n)
actor = n >= 1 ? $game_actors[n] : nil
actor ? actor.name : ""
end
#--------------------------------------------------------------------------
# ○ パーティメンバー n 番の名前を取得
#--------------------------------------------------------------------------
def party_member_name(n)
actor = n >= 1 ? $game_party.members[n - 1] : nil
actor ? actor.name : ""
end
#--------------------------------------------------------------------------
# ○ 配列を全て整数にする
#--------------------------------------------------------------------------
def params_to_i(params)
ret = []
params.each {|param| ret.push(param.to_i)}
return ret
end
#--------------------------------------------------------------------------
# ○ 注釈コマンド定義
#--------------------------------------------------------------------------
def define_command
@cmd_108 = {}
end
#--------------------------------------------------------------------------
# ○ 注釈コマンド定義取得
#--------------------------------------------------------------------------
def cmd_108
@cmd_108
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
end
#--------------------------------------------------------------------------
# ○ 文字の幅と高さを取得
#--------------------------------------------------------------------------
def text_size(font, size, text)
bitmap = Cache.system("")
bitmap.font.name = font
bitmap.font.size = size
tw = bitmap.text_size(text).width
th = bitmap.text_size(text).height
bitmap.dispose
return [tw, th]
end
#--------------------------------------------------------------------------
# ○ 文字の幅を取得
#--------------------------------------------------------------------------
def text_width(font, text)
texts = text.split("\n")
@max_width = 0
texts.each {|text|
width = text_size(font.name, font.size, text)[0]
@max_width = @max_width < width ? width : @max_width
}
return @max_width
end
end
#==============================================================================
# ◆ RGSS3用処理
#==============================================================================
if rgss_version == 3
#==============================================================================
# ■ RPG::Tileset
#==============================================================================
class RPG::Tileset
#--------------------------------------------------------------------------
# ○ 拡張通行判定
#--------------------------------------------------------------------------
def ex_flags
@ex_flags ||= Table.new(8192)
return @ex_flags
end
#--------------------------------------------------------------------------
# ○ 拡張通行判定初期化
#--------------------------------------------------------------------------
def init_ex_flags
@ex_flags = Table.new(8192)
end
end
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、
# Game_Troop クラス、Game_Event クラスの内部で使用されます。
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# ☆ オブジェクト初期化
# depth : ネストの深さ
#--------------------------------------------------------------------------
alias a1_common_gi_rgss3_initialize initialize
def initialize(depth = 0, sub_interpreter = false)
@sub_interpreter = sub_interpreter
a1_common_gi_rgss3_initialize(depth)
end
#--------------------------------------------------------------------------
# ☆ メッセージ表示がビジー状態の間ウェイト
#--------------------------------------------------------------------------
alias a1_common_gi_wait_for_message wait_for_message
def wait_for_message
return if @sub_interpreter
a1_common_gi_wait_for_message
end
end
#==============================================================================
# ■ Window_Message
#------------------------------------------------------------------------------
# 　文章表示に使うメッセージウィンドウです。
#==============================================================================
class Window_Message < Window_Base
#--------------------------------------------------------------------------
# ☆ 通常文字の処理
#--------------------------------------------------------------------------
alias a1_common_wm_process_normal_character process_normal_character
def process_normal_character(c, pos)
wait_for_one_character_before
a1_common_wm_process_normal_character(c, pos)
end
#--------------------------------------------------------------------------
# ○ 一文字出力前のウェイト
#--------------------------------------------------------------------------
def wait_for_one_character_before
end
end
#==============================================================================
# ■ RPG::Map
#==============================================================================
class RPG::Map
#--------------------------------------------------------------------------
# ○ マップチップを調べるか判定する
#--------------------------------------------------------------------------
def search_map_chip?
return true if $a1_common.note_data(self.note, "マップチップサーチ")
return false
end
end
#==============================================================================
# ■ Game_Map
#------------------------------------------------------------------------------
# 　マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。
# このクラスのインスタンスは $game_map で参照されます。
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# ☆ セットアップ
#--------------------------------------------------------------------------
alias a1_common_gm_setup setup
def setup(map_id)
a1_common_gm_setup(map_id)
setup_tileset
map_chip_search if search_map_chip?
end
#--------------------------------------------------------------------------
# ★ タイルセットの取得
#--------------------------------------------------------------------------
def tileset
setup_tileset unless @tileset && @now_tileset_id == @tileset_id
return @tileset
end
#--------------------------------------------------------------------------
# ○ タイルセットのセットアップ
#--------------------------------------------------------------------------
def setup_tileset
@tileset = $data_tilesets[@tileset_id].clone
@tileset.flags = $data_tilesets[@tileset_id].flags.clone
@now_tileset_id = @tileset_id
end
#--------------------------------------------------------------------------
# ○ マップチップを調べるか判定する
#--------------------------------------------------------------------------
def search_map_chip?
return @map.search_map_chip?
end
#--------------------------------------------------------------------------
# ○ 指定座標の全レイヤーのフラグ判定（イベント含む）
#--------------------------------------------------------------------------
def all_tiles_flag?(x, y, bit)
all_tiles(x, y).any? {|tile_id| tileset.flags[tile_id] & bit != 0 }
end
#--------------------------------------------------------------------------
# ○ 指定座標の全レイヤーの拡張フラグ判定（イベント含む）
#--------------------------------------------------------------------------
def all_tiles_flag_ex?(x, y, bit)
all_tiles(x, y).any? {|tile_id| tileset.ex_flags[tile_id] & bit != 0 }
end
#--------------------------------------------------------------------------
# ○ 指定座標の全レイヤーの拡張フラグ判定
#--------------------------------------------------------------------------
def layered_tiles_flag_ex?(x, y, bit)
layered_tiles(x, y).any? {|tile_id| tileset.ex_flags[tile_id] & bit != 0 }
end
#--------------------------------------------------------------------------
# ○ 地形タグの取得（イベント含む）
#--------------------------------------------------------------------------
def terrain_tag_all_tailes(x, y)
return 0 unless valid?(x, y)
all_tiles(x, y).each do |tile_id|
tag = tileset.flags[tile_id] >> 12
return tag if tag > 0
end
return 0
end
end
#==============================================================================
# ■ DataManager
#------------------------------------------------------------------------------
# 　データベースとゲームオブジェクトを管理するモジュールです。ゲームで使用する
# ほぼ全てのグローバル変数はこのモジュールで初期化されます。
#==============================================================================
module DataManager
#--------------------------------------------------------------------------
# ○ エイリアス用特異メソッド
#--------------------------------------------------------------------------
class << self
alias :a1_common_create_game_objects :create_game_objects
end
#--------------------------------------------------------------------------
# ☆ 各種ゲームオブジェクトの作成
#--------------------------------------------------------------------------
def self.create_game_objects
$a1_common ||= A1_System::CommonModule.new
a1_common_create_game_objects
end
end
#==============================================================================
# ■ Scene_Base
#------------------------------------------------------------------------------
# 　ゲーム中の全てのシーンのスーパークラスです。
#==============================================================================
class Scene_Base
#--------------------------------------------------------------------------
# ☆ フレーム更新（基本）
#--------------------------------------------------------------------------
alias a1_common_sb_update_basic update_basic
def update_basic
a1_common_sb_update_basic
$a1_common.update
end
#--------------------------------------------------------------------------
# ○ 指定のウィンドウが開いている間ウェイト
#--------------------------------------------------------------------------
def wait_for_window_open(window)
update_basic until window.openness == 0
end
end
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　ゲーム中の全てのウィンドウのスーパークラスです。
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# ★ 制御文字の事前変換
# 実際の描画を始める前に、原則として文字列に変わるものだけを置き換える。
# 文字「\」はエスケープ文字（\e）に変換。
#--------------------------------------------------------------------------
def convert_escape_characters(text)
return $a1_common.convert_escape_characters(text)
end
end
#==============================================================================
# ◆ RGSS2用処理
#==============================================================================
elsif rgss_version == 2
#==============================================================================
# ■ Window
#==============================================================================
class Window
#--------------------------------------------------------------------------
# ○ ウィンドウが開いている？
#--------------------------------------------------------------------------
def open?
return self.openness == 255
end
#--------------------------------------------------------------------------
# ○ ウィンドウが閉じている？
#--------------------------------------------------------------------------
def close?
return self.openness == 0
end
end
#==============================================================================
# ■ Cache
#------------------------------------------------------------------------------
# 　各種グラフィックを読み込み、Bitmap オブジェクトを作成、保持するモジュール
# です。読み込みの高速化とメモリ節約のため、作成した Bitmap オブジェクトを内部
# のハッシュに保存し、同じビットマップが再度要求されたときに既存のオブジェクト
# を返すようになっています。
#==============================================================================
module Cache
#--------------------------------------------------------------------------
# ○ キャッシュ存在チェック
#--------------------------------------------------------------------------
def self.include?(key)
@cache[key] && !@cache[key].disposed?
end
end
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、
# Game_Troop クラス、Game_Event クラスの内部で使用されます。
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# ○ 注釈
#--------------------------------------------------------------------------
def command_108
@comments = [@params[0]]
while next_event_code == 408
@index += 1
@comments.push(@list[@index].parameters[0])
end
end
#--------------------------------------------------------------------------
# ★ イベントコマンドの実行
#--------------------------------------------------------------------------
def execute_command
return rgss3_execute_command unless @index >= @list.size-1
command_end
return true
end
#--------------------------------------------------------------------------
# ○ RGSS3風「イベントコマンドの実行」
#--------------------------------------------------------------------------
def rgss3_execute_command
command = @list[@index]
@params = command.parameters
@indent = command.indent
method_name = "command_#{command.code}"
send(method_name) if respond_to?(method_name)
end
#--------------------------------------------------------------------------
# ○ 次のイベントコマンドのコードを取得
#--------------------------------------------------------------------------
def next_event_code
@list[@index + 1].code
end
end
#==============================================================================
# ■ Game_Map
#------------------------------------------------------------------------------
# 　マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。
# このクラスのインスタンスは $game_map で参照されます。
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# ○ マップチップを調べるか判定する
#--------------------------------------------------------------------------
def search_map_chip?
return $data_map_infos[@map_id].name =~ /\[サーチ\]/
end
#--------------------------------------------------------------------------
# ○ 指定座標に存在するタイル扱いイベント（すり抜け以外）の配列取得
#--------------------------------------------------------------------------
def tile_events_xy(x, y)
@tile_events.select {|event| event.pos_nt?(x, y) }
end
#--------------------------------------------------------------------------
# ○ タイル扱いイベントの配列をリフレッシュ
#--------------------------------------------------------------------------
def refresh_tile_events
@tile_events = @events.values.select {|event| event.tile? }
end
end
#==============================================================================
# ■ Game_Character
#------------------------------------------------------------------------------
# 　キャラクターを扱うクラスです。このクラスは Game_Player クラスと Game_Event
# クラスのスーパークラスとして使用されます。
#==============================================================================
class Game_Character
#--------------------------------------------------------------------------
# ○ タイル判定
#--------------------------------------------------------------------------
def tile?
@tile_id > 0 && @priority_type == 0
end
end
#==============================================================================
# ■ Scene_Title
#------------------------------------------------------------------------------
# 　タイトル画面の処理を行うクラスです。
#==============================================================================
class Scene_Title < Scene_Base
#--------------------------------------------------------------------------
# ☆ データベースのロード
#--------------------------------------------------------------------------
alias a1_common_st_load_database load_database
def load_database
a1_common_st_load_database
$data_map_infos = load_data("Data/MapInfos.rvdata")
end
#--------------------------------------------------------------------------
# ☆ 各種ゲームオブジェクトの作成
#--------------------------------------------------------------------------
alias a1_common_st_create_game_objects create_game_objects
def create_game_objects
$a1_common ||= A1_System::CommonModule.new
a1_common_st_create_game_objects
end
end
#==============================================================================
# ◆ RGSS用処理
#==============================================================================
elsif rgss_version == 1
end
#==============================================================================
# ■ Cache
#------------------------------------------------------------------------------
# 　各種グラフィックを読み込み、Bitmap オブジェクトを作成、保持するモジュール
# です。読み込みの高速化とメモリ節約のため、作成した Bitmap オブジェクトを内部
# のハッシュに保存し、同じビットマップが再度要求されたときに既存のオブジェクト
# を返すようになっています。
#==============================================================================
module Cache
#--------------------------------------------------------------------------
# ○ 拡大縮小したビットマップのロード
#--------------------------------------------------------------------------
def self.load_resize_bitmap(load_path, key, resize = nil)
@cache ||= {}
key = load_path if key == nil
return @cache[key] if include?(key)
@cache[key] = Bitmap.new(load_path)
return @cache[key] if resize == nil
return @cache[key] if @cache[key].width == resize[0] and @cache[key].height == resize[1]
info = calc_size(resize, key)
return resize_bitmap(@cache[key], info[0], info[1], key)
end
#--------------------------------------------------------------------------
# ○ 拡大縮小した色相変化済みビットマップを作成／取得
#--------------------------------------------------------------------------
def self.load_resize_hue_changed_bitmap(load_path, path, hue, resize)
key = [path, hue]
return @cache[key] if include?(key)
@cache[key] = load_resize_bitmap(load_path, path, resize).clone
@cache[key].hue_change(hue)
return @cache[key]
end
#--------------------------------------------------------------------------
# ○ リサイズするサイズを取得
#--------------------------------------------------------------------------
def self.calc_size(resize, key)
width = resize[0]
width = @cache[key].width * width.abs if width < 0
height = resize[1]
height = @cache[key].height * height.abs if height < 0
height = Integer(@cache[key].height * (width.to_f / @cache[key].width.to_f)) if height == 0
return [width, height]
end
#--------------------------------------------------------------------------
# ○ ビットマップの拡大縮小
#--------------------------------------------------------------------------
def self.resize_bitmap(bitmap, width, height, key)
resize = Bitmap.new(width, height)
resize.stretch_blt(resize.rect, bitmap, bitmap.rect)
@cache[key] = resize
return resize
end
#--------------------------------------------------------------------------
# ○ テキストビットマップの取得
#--------------------------------------------------------------------------
def self.text_picture(text, font)
load_text_bitmap(text, font)
end
#--------------------------------------------------------------------------
# ○ フォントのキーを作成
#--------------------------------------------------------------------------
def self.make_font_key(text, font)
[text, font.name, font.size, font.bold, font.italic, font.outline, font.shadow, font.color.to_s, font.out_color.to_s]
end
#--------------------------------------------------------------------------
# ○ テキストビットマップの作成
#--------------------------------------------------------------------------
def self.load_text_bitmap(text, font)
@cache ||= {}
key = make_font_key(text, font)
return @cache[key] if include?(key)
# 計算用ダミービットマップ
bitmap = Cache.system("")
bitmap.font = font
tw = bitmap.text_size(text).width + 8
# ビットマップ作成
bitmap = Bitmap.new(tw, bitmap.font.size + 4)
bitmap.font = font
bitmap.draw_text(0, 0, bitmap.width, bitmap.height, text, 1)
@cache[key] = bitmap
return @cache[key]
end
end
#==============================================================================
# ■ Game_Interpreter
#------------------------------------------------------------------------------
# 　イベントコマンドを実行するインタプリタです。このクラスは Game_Map クラス、
# Game_Troop クラス、Game_Event クラスの内部で使用されます。
#==============================================================================
class Game_Interpreter
#--------------------------------------------------------------------------
# ○ 注釈
#--------------------------------------------------------------------------
alias a1_common_command_108 command_108
def command_108
a1_common_command_108
proc_comment(@comments)
end
#--------------------------------------------------------------------------
# ○ 注釈の処理
#--------------------------------------------------------------------------
def proc_comment(comments)
param = ""
comments.each {|comment| param += comment }
params = param.sub(/^(\S+)/, "")
command = $1
comment_parameters = $a1_common.split_array(params) if params
proc_comment_command(command, comment_parameters)
end
#--------------------------------------------------------------------------
# ○ 注釈の実行
#--------------------------------------------------------------------------
def proc_comment_command(command, params)
cmd_108 = $a1_common.cmd_108[command]
method(cmd_108).call(params) if cmd_108 != nil
end
#--------------------------------------------------------------------------
# ○ 前のイベントコマンドを取得
#--------------------------------------------------------------------------
def prev_event
@list[@index - 1]
end
end
#==============================================================================
# ■ Game_Map
#------------------------------------------------------------------------------
# 　マップを扱うクラスです。スクロールや通行可能判定などの機能を持っています。
# このクラスのインスタンスは $game_map で参照されます。
#==============================================================================
class Game_Map
#--------------------------------------------------------------------------
# ○ 全マップチップを調べる
#--------------------------------------------------------------------------
def map_chip_search
tileset.init_ex_flags
([email protected]).each {|x| map_chip_search_y(x) }
end
#--------------------------------------------------------------------------
# ○ x座標にあるy座標のマップチップを調べる
#--------------------------------------------------------------------------
def map_chip_search_y(x)
([email protected]).each {|y| map_pos_proc(x, y); map_chip_search_z(x, y) }
end
#--------------------------------------------------------------------------
# ○ x,y座標にあるz座標のマップチップを調べる
#--------------------------------------------------------------------------
def map_chip_search_z(x, y)
([email protected]).each {|z| map_chip_proc(x, y, z) }
tile_events_xy(x, y).collect {|ev| tile_event_proc(ev.tile_id) }
end
#--------------------------------------------------------------------------
# ○ 座標に対して処理を行う
#--------------------------------------------------------------------------
def map_pos_proc(x, y)
end
#--------------------------------------------------------------------------
# ○ マップチップに対して処理を行う
#--------------------------------------------------------------------------
def map_chip_proc(x, y, z)
end
#--------------------------------------------------------------------------
# ○ タイルのイベントに対して処理を行う
#--------------------------------------------------------------------------
def tile_event_proc(tile_id)
end
end
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　ゲーム中の全てのウィンドウのスーパークラスです。
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# ○ 入力を受け付けるか？
#--------------------------------------------------------------------------
def can_input?
@can_input
end
#--------------------------------------------------------------------------
# ○ 入力受け付け設定
#--------------------------------------------------------------------------
def can_input=(flag)
@can_input = flag
end
end
#==============================================================================
# ■ Bitmap
#==============================================================================
class Bitmap
#--------------------------------------------------------------------------
# ○ 文字縁取り描画
#--------------------------------------------------------------------------
def draw_text_f(x, y, width, height, str, align = 0, color = Color.new(64,32,128))
shadow = self.font.shadow
b_color = self.font.color.dup
font.shadow = false
font.color = color
draw_text(x + 1, y, width, height, str, align)
draw_text(x - 1, y, width, height, str, align)
draw_text(x, y + 1, width, height, str, align)
draw_text(x, y - 1, width, height, str, align)
font.color = b_color
draw_text(x, y, width, height, str, align)
font.shadow = shadow
end
#--------------------------------------------------------------------------
# ○ 文字縁取り描画の矩形を取得
#--------------------------------------------------------------------------
def draw_text_f_rect(r, str, align = 0, color = Color.new(64,32,128))
draw_text_f(r.x, r.y, r.width, r.height, str, align = 0, color)
end
end

复制代码

A1バトル共通スクリプト

# ===========================================================================
# ◆ A1 Scripts ◆
# A1バトル共通スクリプト（RGSS3）
#
# バージョン： 1.23 (2012/01/27)
# 作者： A1
# URL　　　　　： http://a1tktk.web.fc2.com/
# ---------------------------------------------------------------------------
# 更新履歴　　：2012/01/18 Ver1.00 リリース
# 2012/01/21 Ver1.10 装備拡張対応
# 2012/01/21 Ver1.10 メンバー加入時の不具合を修正
# 2012/01/21 Ver1.10 メンバー加入時に既にパーティに居るさい何もしないように修正
# 2012/01/24 Ver1.20 スキル拡張対応
# 2012/01/24 Ver1.21 Window_BattleActorの不具合を修正
# 2012/01/26 Ver1.22 Window_BattleSkillの不具合を修正
# 2012/01/27 Ver1.23 戦闘行動がない際の不具合を修正
# ---------------------------------------------------------------------------
# 設置場所
#　　A1共通スクリプトより下
# 一部再定義メソッドがあるため、なるべく上の方
#
# 必要スクリプト
# A1共通スクリプトVer4.30以上
#==============================================================================
$imported = {} if $imported == nil
if $imported["A1_Common_Script"]
$imported["A1_BattleCommonScript"] = true
old_common_script("A1バトル共通スクリプト", "4.30") if common_version < 4.30
#==============================================================================
# ■ Window_Base
#------------------------------------------------------------------------------
# 　ゲーム中の全てのウィンドウのスーパークラスです。
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# ○ メソッドの定義
#--------------------------------------------------------------------------
def define_method(method, symbol)
@method ||= {}
@method[symbol] = method
end
#--------------------------------------------------------------------------
# ○ メソッドのコール
#--------------------------------------------------------------------------
def call_method(symbol, *args)
@method ||= {}
@method[symbol].call(*args) if @method[symbol]
end
#--------------------------------------------------------------------------
# ○ 顔グラフィックの描画(解放なし)
#--------------------------------------------------------------------------
def draw_face_no_dispose(face_name, face_index, x, y, enabled = true)
bitmap = Cache.face(face_name)
rect = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96)
contents.blt(x, y, bitmap, rect, enabled ? 255 : translucent_alpha)
end
#--------------------------------------------------------------------------
# ○ 背景の描画
#--------------------------------------------------------------------------
def draw_background(rect)
temp_rect = rect.clone
temp_rect.width /= 2
contents.gradient_fill_rect(temp_rect, back_color2, back_color1)
temp_rect.x = temp_rect.width
contents.gradient_fill_rect(temp_rect, back_color1, back_color2)
end
#--------------------------------------------------------------------------
# ○ 背景色 1 の取得
#--------------------------------------------------------------------------
def back_color1
Color.new(0, 0, 0, 192)
end
#--------------------------------------------------------------------------
# ○ 背景色 2 の取得
#--------------------------------------------------------------------------
def back_color2
Color.new(0, 0, 0, 0)
end
end
#==============================================================================
# ■ Window_Help
#------------------------------------------------------------------------------
# 　スキルやアイテムの説明、アクターのステータスなどを表示するウィンドウです。
#==============================================================================
class Window_Help < Window_Base
#--------------------------------------------------------------------------
# ○ センターにテキストを描画
#--------------------------------------------------------------------------
def draw_center_text(text)
contents.clear
draw_text(0, 0, contents.width, line_height, text, 1)
end
end
#==============================================================================
# ■ Window_BattleActor
#------------------------------------------------------------------------------
# 　バトル画面で、行動対象のアクターを選択するウィンドウです。
#==============================================================================
class Window_BattleActor < Window_BattleStatus
#--------------------------------------------------------------------------
# ★ ウィンドウの表示
#--------------------------------------------------------------------------
def show
setup_remain if @info_viewport
self.visible = true
refresh
open
self
end
#--------------------------------------------------------------------------
# ★ ウィンドウの非表示
#--------------------------------------------------------------------------
def hide
close
@info_viewport.rect.width = Graphics.width if @info_viewport
call_method(:select_actor_end)
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
return update_basic unless self.visible
super
self.visible = false if self.openness == 0
end
#--------------------------------------------------------------------------
# ○ フレーム更新(基本)
#--------------------------------------------------------------------------
def update_basic
process_cursor_move
process_handling
end
#--------------------------------------------------------------------------
# ○ 項目の選択
#--------------------------------------------------------------------------
def select(index)
super
call_method(:select_actor, index)
end
#--------------------------------------------------------------------------
# ○ ウィンドウの調整
#--------------------------------------------------------------------------
def setup_remain
width_remain = Graphics.width - width
self.x = width_remain
@info_viewport.rect.width = width_remain
select(0)
end
end
#==============================================================================
# ■ Window_BattleEnemy
#------------------------------------------------------------------------------
# 　バトル画面で、行動対象の敵キャラを選択するウィンドウです。
#==============================================================================
class Window_BattleEnemy < Window_Selectable
#--------------------------------------------------------------------------
# ★ ウィンドウの表示
#--------------------------------------------------------------------------
def show
setup_remain if @info_viewport
self.visible = true
open
self
end
#--------------------------------------------------------------------------
# ★ ウィンドウの非表示
#--------------------------------------------------------------------------
def hide
close
@info_viewport.rect.width = Graphics.width if @info_viewport
call_method(:select_enemy_end)
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
return update_basic unless self.visible
super
self.visible = false if self.openness == 0
end
#--------------------------------------------------------------------------
# ○ フレーム更新(基本)
#--------------------------------------------------------------------------
def update_basic
process_cursor_move
process_handling
end
#--------------------------------------------------------------------------
# ○ 項目の選択
#--------------------------------------------------------------------------
def select(index)
super
call_method(:select_enemy, index)
end
#--------------------------------------------------------------------------
# ○ ウィンドウの調整
#--------------------------------------------------------------------------
def setup_remain
width_remain = Graphics.width - width
self.x = width_remain
@info_viewport.rect.width = width_remain
select(0)
end
end
#==============================================================================
# ■ Window_BattleSkill
#------------------------------------------------------------------------------
# 　バトル画面で、使用するスキルを選択するウィンドウです。
#==============================================================================
class Window_BattleSkill < Window_SkillList
#--------------------------------------------------------------------------
# ☆ オブジェクト初期化
# info_viewport : 情報表示用ビューポート
#--------------------------------------------------------------------------
alias a1_psw_wbs_initialize initialize
def initialize(help_window, info_viewport)
a1_psw_wbs_initialize(help_window, info_viewport)
self.openness = 0
self.visible = true
@help_window.openness = 0
@help_window.visible = true
end
#--------------------------------------------------------------------------
# ○ 高さを変える
#--------------------------------------------------------------------------
def resize_height(base_y)
self.height = base_y - self.y
create_contents
end
#--------------------------------------------------------------------------
# ★ ウィンドウの表示
#--------------------------------------------------------------------------
def show
self.visible = true
@help_window.visible = true
select_last
open
@help_window.open
self
end
#--------------------------------------------------------------------------
# ★ ウィンドウの非表示
#--------------------------------------------------------------------------
def hide
close
@help_window.close
@info_viewport.rect.width = Graphics.width if @info_viewport
call_method(:skill_item_window_hide)
end
#--------------------------------------------------------------------------
# ○ オープン
#--------------------------------------------------------------------------
def open
self.visible = true
call_method(:skill_item_window_show)
super
end
#--------------------------------------------------------------------------
# ○ アクティブ化
#--------------------------------------------------------------------------
def activate
open
@help_window.open
super
end
end
#==============================================================================
# ■ Window_BattleItem
#------------------------------------------------------------------------------
# 　バトル画面で、使用するアイテムを選択するウィンドウです。
#==============================================================================
class Window_BattleItem < Window_ItemList
#--------------------------------------------------------------------------
# ☆ オブジェクト初期化
# info_viewport : 情報表示用ビューポート
#--------------------------------------------------------------------------
alias a1_battle_common_wbi_initialize initialize
def initialize(help_window, info_viewport)
a1_battle_common_wbi_initialize(help_window, info_viewport)
self.openness = 0
self.visible = true
@help_window.openness = 0
@help_window.visible = true
end
#--------------------------------------------------------------------------
# ○ 高さを変える
#--------------------------------------------------------------------------
def resize_height(base_y)
self.height = base_y - self.y
create_contents
end
#--------------------------------------------------------------------------
# ★ ウィンドウの表示
#--------------------------------------------------------------------------
def show
self.visible = true
@help_window.visible = true
select_last
open
@help_window.open
self
end
#--------------------------------------------------------------------------
# ★ ウィンドウの非表示
#--------------------------------------------------------------------------
def hide
close
@help_window.close
call_method(:skill_item_window_hide)
end
#--------------------------------------------------------------------------
# ○ オープン
#--------------------------------------------------------------------------
def open
self.visible = true
call_method(:skill_item_window_show)
super
end
#--------------------------------------------------------------------------
# ○ アクティブ化
#--------------------------------------------------------------------------
def activate
open
@help_window.open
super
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
return unless self.visible
super
self.visible = false if self.openness == 0
end
end
#==============================================================================
# ■ Window_ActorCommand
#------------------------------------------------------------------------------
# 　バトル画面で、アクターの行動を選択するウィンドウです。
#==============================================================================
class Window_ActorCommand < Window_Command
#--------------------------------------------------------------------------
# ☆ セットアップ
#--------------------------------------------------------------------------
alias a1_battle_common_wac_setup setup
def setup(actor)
call_method(:actor_command_setup, actor)
a1_battle_common_wac_setup(actor)
end
#--------------------------------------------------------------------------
# ○ ウィンドウのアクティブ化
#--------------------------------------------------------------------------
def activate
open
super
end
#--------------------------------------------------------------------------
# ○ オープン
#--------------------------------------------------------------------------
def open
call_method(:actor_command_open)
super
end
#--------------------------------------------------------------------------
# ○ クローズ
#--------------------------------------------------------------------------
def close
call_method(:actor_command_close)
super
end
end
#==============================================================================
# ■ Window_BattleStatus
#------------------------------------------------------------------------------
# 　バトル画面で、パーティメンバーのステータスを表示するウィンドウです。
#==============================================================================
class Window_BattleStatus < Window_Selectable
#--------------------------------------------------------------------------
# ☆ リフレッシュ
#--------------------------------------------------------------------------
alias a1_battle_common_wbs_refresh refresh
def refresh
call_method(:refresh_statsu_window)
return unless self.visible
a1_battle_common_wbs_refresh
end
#--------------------------------------------------------------------------
# ○ ウィンドウを開く
#--------------------------------------------------------------------------
def open
super
call_method(:open_status_window)
end
#--------------------------------------------------------------------------
# ○ ウィンドウを閉じる
#--------------------------------------------------------------------------
def close
super
call_method(:close_status_window)
end
#--------------------------------------------------------------------------
# ○ 項目の選択
#--------------------------------------------------------------------------
def select(index)
super
call_method(:select_status_window, index)
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
call_method(:update_status_window)
return unless self.visible
super
end
#--------------------------------------------------------------------------
# ○ 解放
#--------------------------------------------------------------------------
def dispose
super
call_method(:dispose_status_window)
end
end
#==============================================================================
# ■ Window_PersonalStatus
#==============================================================================
class Window_PersonalStatus < Window_Base
#--------------------------------------------------------------------------
# ○ オブジェクト初期化
#--------------------------------------------------------------------------
def initialize(x, y, opacity = 0)
super(x, y, Graphics.width / 2, 120)
self.opacity = opacity
self.openness = 0
@actor = nil
end
#--------------------------------------------------------------------------
# ○ アクターの設定
#--------------------------------------------------------------------------
def actor=(actor)
@actor = actor
refresh
end
#--------------------------------------------------------------------------
# ○ リフレッシュ
#--------------------------------------------------------------------------
def refresh
contents.clear
draw_face(@actor.face_name, @actor.face_index, 0, 0)
draw_text(116, line_height * 0, contents.width, line_height, @actor.name)
draw_actor_level(@actor, 116, 0 + line_height * 1)
draw_actor_icons(@actor, 180, 0 + line_height * 1)
draw_actor_hp(@actor, 116, 0 + line_height * 2, 128)
draw_actor_mp(@actor, 116, 0 + line_height * 3, 60)
draw_actor_tp(@actor, 184, 0 + line_height * 3, 60) if $data_system.opt_display_tp
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
return unless self.visible
super
self.visible = false if self.openness == 0
end
#--------------------------------------------------------------------------
# ○ オープン
#--------------------------------------------------------------------------
def open
self.visible = true
super
end
#--------------------------------------------------------------------------
# ○ 顔グラフィックの描画
#--------------------------------------------------------------------------
def draw_face(face_name, face_index, x, y, enabled = true)
draw_face_no_dispose(face_name, face_index, x, y, enabled)
end
end
#==============================================================================
# ■ RPG::Enemy
#==============================================================================
class RPG::Enemy < RPG::BaseItem
#--------------------------------------------------------------------------
# ○ 初期装備
#--------------------------------------------------------------------------
def equips
@equips ||= [0,0,0,0,0]
@equips[0] ||= $a1_common.note_data_one(self.note, "エネミー武器", 0)
return @equips
end
end
#==============================================================================
# ■ Game_Enemy
#------------------------------------------------------------------------------
# 　敵キャラを扱うクラスです。このクラスは Game_Troop クラス（$game_troop）の
# 内部で使用されます。
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# ☆ オブジェクト初期化
#--------------------------------------------------------------------------
alias a1_battle_common_ge_initialize initialize
def initialize(index, enemy_id)
@equips = []
a1_battle_common_ge_initialize(index, enemy_id)
init_equips(enemy.equips)
end
end
#==============================================================================
# ■ Game_Actor
#------------------------------------------------------------------------------
# 　アクターを扱うクラスです。このクラスは Game_Actors クラス（$game_actors）
# の内部で使用され、Game_Party クラス（$game_party）からも参照されます。
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ★ 装備品の初期化
# equips : 初期装備の配列
#--------------------------------------------------------------------------
def init_equips(equips)
super
end
#--------------------------------------------------------------------------
# ★ 装備タイプからスロット ID に変換（空きを優先）
#--------------------------------------------------------------------------
def empty_slot(etype_id)
super
end
#--------------------------------------------------------------------------
# ★ 装備タイプからスロット ID のリストに変換
#--------------------------------------------------------------------------
def slot_list(etype_id)
super
end
#--------------------------------------------------------------------------
# ★ エディタで設定されたインデックスを装備タイプ ID に変換
#--------------------------------------------------------------------------
def index_to_etype_id(index)
super
end
#--------------------------------------------------------------------------
# ★ 装備スロットの配列を取得
#--------------------------------------------------------------------------
def equip_slots
super
end
#--------------------------------------------------------------------------
# ★ 装備品オブジェクトの配列取得
#--------------------------------------------------------------------------
def equips
super
end
#--------------------------------------------------------------------------
# ★ 武器オブジェクトの配列取得
#--------------------------------------------------------------------------
def weapons
super
end
#--------------------------------------------------------------------------
# ★ 通常能力値の加算値取得
#--------------------------------------------------------------------------
def param_plus(param_id)
super
end
#--------------------------------------------------------------------------
# ☆ 通常攻撃アニメーション ID の取得
#--------------------------------------------------------------------------
alias a1_battle_common_ga_atk_animation_id1 atk_animation_id1
def atk_animation_id1
return a1_battle_common_ga_atk_animation_id1 if !@current_weapon || @current_weapon.is_a?(Array)
@current_weapon.animation_id
end
#--------------------------------------------------------------------------
# ☆ 通常攻撃アニメーション ID の取得（二刀流：武器２）
#--------------------------------------------------------------------------
alias a1_battle_common_ga_atk_animation_id2 atk_animation_id2
def atk_animation_id2
return a1_battle_common_ga_atk_animation_id2 if !@current_weapon || @current_weapon.is_a?(Array)
@current_weapon.animation_id
end
#--------------------------------------------------------------------------
# ○ 装備タイプ名を取得
#--------------------------------------------------------------------------
def e_type_name(item)
return $data_system.weapon_types[item.wtype_id] if item.is_a?(RPG::Weapon)
return $data_system.armor_types[item.atype_id] if item.is_a?(RPG::Armor)
end
end
#==============================================================================
# ■ Game_BattlerBase
#------------------------------------------------------------------------------
# 　バトラーを扱う基本のクラスです。主に能力値計算のメソッドを含んでいます。こ
# のクラスは Game_Battler クラスのスーパークラスとして使用されます。
#==============================================================================
class Game_BattlerBase
#--------------------------------------------------------------------------
# ○ 二刀流？
#--------------------------------------------------------------------------
def two_sword_style?
weapons[0] && weapons[1]
end
#--------------------------------------------------------------------------
# ○ バトラーオブジェクト取得
#--------------------------------------------------------------------------
def battler
return actor if self.actor?
return enemy
end
end
#==============================================================================
# ■ Game_Battler
#------------------------------------------------------------------------------
# 　スプライトや行動に関するメソッドを追加したバトラーのクラスです。このクラス
# は Game_Actor クラスと Game_Enemy クラスのスーパークラスとして使用されます。
#==============================================================================
class Game_Battler < Game_BattlerBase
#--------------------------------------------------------------------------
# ○ 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :current_weapon
attr_accessor :current_main
#--------------------------------------------------------------------------
# ○ 装備品の初期化
# equips : 初期装備の配列
#--------------------------------------------------------------------------
def init_equips(equips)
@equips = Array.new(equip_slots.size) { Game_BaseItem.new }
equips.each_with_index do |item_id, i|
etype_id = index_to_etype_id(i)
slot_id = empty_slot(etype_id)
@equips[slot_id].set_equip(etype_id == 0, item_id) if slot_id
end
refresh
end
#--------------------------------------------------------------------------
# ○ 装備タイプからスロット ID に変換（空きを優先）
#--------------------------------------------------------------------------
def empty_slot(etype_id)
list = slot_list(etype_id)
list.find {|i| @equips[i].is_nil? } || list[0]
end
#--------------------------------------------------------------------------
# ○ 装備タイプからスロット ID のリストに変換
#--------------------------------------------------------------------------
def slot_list(etype_id)
result = []
equip_slots.each_with_index {|e, i| result.push(i) if e == etype_id }
result
end
#--------------------------------------------------------------------------
# ○ エディタで設定されたインデックスを装備タイプ ID に変換
#--------------------------------------------------------------------------
def index_to_etype_id(index)
index == 1 && dual_wield? ? 0 : index
end
#--------------------------------------------------------------------------
# ○ 装備スロットの配列を取得
#--------------------------------------------------------------------------
def equip_slots
return [0,0,2,3,4] if dual_wield? # 二刀流
return [0,1,2,3,4] # 通常
end
#--------------------------------------------------------------------------
# ○ 装備品オブジェクトの配列取得
#--------------------------------------------------------------------------
def equips
@equips.collect {|item| item.object }
end
#--------------------------------------------------------------------------
# ○ 武器オブジェクトの配列取得
#--------------------------------------------------------------------------
def weapons
@equips.select {|item| item.is_weapon? }.collect {|item| item.object }
end
#--------------------------------------------------------------------------
# ○ 通常能力値の加算値取得
#--------------------------------------------------------------------------
def param_plus(param_id)
equips.compact.inject(super) {|r, item| r += item.params[param_id] + ex_item_params(item, param_id) }
end
#--------------------------------------------------------------------------
# ○ アイテムにかける追加要素
#--------------------------------------------------------------------------
def ex_item_params(item, param_id)
return 0
end
#--------------------------------------------------------------------------
# ○ スキルを取得
#--------------------------------------------------------------------------
def skill(skill_id)
$data_skills[skill_id]
end
end
#==============================================================================
# ■ Game_Party
#------------------------------------------------------------------------------
# 　パーティを扱うクラスです。所持金やアイテムなどの情報が含まれます。このクラ
# スのインスタンスは $game_party で参照されます。
#==============================================================================
class Game_Party < Game_Unit
#--------------------------------------------------------------------------
# ☆ アクターを加える
#--------------------------------------------------------------------------
alias a1_battle_common_gp_add_actor add_actor
def add_actor(actor_id)
return a1_battle_common_gp_add_actor(actor_id) unless in_battle
return if @actors.include?(actor_id)
prev_add_actor(battle_members)
insert_actor(actor_id)
post_add_actor($game_actors[actor_id])
end
#--------------------------------------------------------------------------
# ○ アクターを加える
#--------------------------------------------------------------------------
def insert_actor(actor_id)
@new_index = @remove_member_index ? @remove_member_index[0] : @actors.size
@actors.insert(@new_index, actor_id) unless @actors.include?(actor_id)
$game_player.refresh
$game_map.need_refresh = true
return unless @remove_member_index
@remove_member_index.delete_at(0)
@remove_member_index = nil if @remove_member_index.empty?
end
#--------------------------------------------------------------------------
# ○ アクターを加えたIndexを取得
#--------------------------------------------------------------------------
def new_index
@new_index
end
#--------------------------------------------------------------------------
# ○ アクターを加える前処理
#--------------------------------------------------------------------------
def prev_add_actor(members)
BattleManager.call_method(:prev_add_battler, members)
end
#--------------------------------------------------------------------------
# ○ アクターを加えた後処理
#--------------------------------------------------------------------------
def post_add_actor(member)
BattleManager.call_method(:post_add_battler, member)
end
#--------------------------------------------------------------------------
# ☆ アクターを外す
#--------------------------------------------------------------------------
alias a1_battle_common_gp_remove_actor remove_actor
def remove_actor(actor_id)
prev_remove_actor($game_actors[actor_id]) if in_battle
a1_battle_common_gp_remove_actor(actor_id)
post_remove_actor if in_battle
end
#--------------------------------------------------------------------------
# ○ アクターを外す前処理
#--------------------------------------------------------------------------
def prev_remove_actor(member)
@remove_member_index ||= []
@remove_member_index.push(member.index)
BattleManager.call_method(:prev_remove_battler, member)
end
#--------------------------------------------------------------------------
# ○ アクターを外した後処理
#--------------------------------------------------------------------------
def post_remove_actor
BattleManager.call_method(:post_remove_battler)
end
end
#==============================================================================
# ■ BattleManager
#------------------------------------------------------------------------------
# 　戦闘の進行を管理するモジュールです。
#==============================================================================
module BattleManager
#--------------------------------------------------------------------------
# ○ エイリアス用特異メソッド
#--------------------------------------------------------------------------
class << self
alias :a1_battle_common_bm_turn_end :turn_end
alias :a1_battle_common_bm_turn_start :turn_start
alias :a1_battle_common_bm_battle_end :battle_end
end
#--------------------------------------------------------------------------
# ☆ ターン開始
#--------------------------------------------------------------------------
def self.turn_start
@turn_end_wait = 0
a1_battle_common_bm_turn_start
end
#--------------------------------------------------------------------------
# ☆ ターン終了
#--------------------------------------------------------------------------
def self.turn_end
call_method(:wait, @turn_end_wait) if @turn_end_wait > 0
@turn_end_wait = 0
a1_battle_common_bm_turn_end
end
#--------------------------------------------------------------------------
# ○ メソッドの設定
#--------------------------------------------------------------------------
def self.define_method(method, symbol)
@method ||= {}
@method[symbol] = method
end
#--------------------------------------------------------------------------
# ○ メソッドのコール
#--------------------------------------------------------------------------
def self.call_method(symbol, *args)
@method[symbol].call(*args) if @method[symbol]
end
#--------------------------------------------------------------------------
# ○ ターン終了後ウェイト設定
#--------------------------------------------------------------------------
def self.turn_end_wait=(flame)
@turn_end_wait = flame if @turn_end_wait < flame || flame == 0
end
#--------------------------------------------------------------------------
# ☆ 戦闘終了
# result : 結果（0:勝利 1:逃走 2:敗北）
#--------------------------------------------------------------------------
def self.battle_end(result)
call_method(:battle_end, result)
a1_battle_common_bm_battle_end(result)
end
end
#==============================================================================
# ■ Game_Action
#------------------------------------------------------------------------------
# 　戦闘行動を扱うクラスです。このクラスは Game_Battler クラスの内部で使用され
# ます。
#==============================================================================
class Game_Action
#--------------------------------------------------------------------------
# ☆ ターゲットの配列作成
#--------------------------------------------------------------------------
alias a1_battle_common_gac_make_targets make_targets
def make_targets
@targets ||= pre_make_targets
return @targets
end
#--------------------------------------------------------------------------
# ○ ターゲットの配列先行作成
#--------------------------------------------------------------------------
def pre_make_targets
@targets = a1_battle_common_gac_make_targets
end
#--------------------------------------------------------------------------
# ○ ターゲットの配列を取得
#--------------------------------------------------------------------------
def targets
@targets.compact
end
#--------------------------------------------------------------------------
# ○ ターゲットの配列をクリア
#--------------------------------------------------------------------------
def clear_targets
@targets = nil
end
end
#==============================================================================
# ■ Scene_Battle
#------------------------------------------------------------------------------
# 　バトル画面の処理を行うクラスです。
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ☆ 開始処理
#--------------------------------------------------------------------------
alias a1_battle_common_sb_start start
def start
a1_battle_common_sb_start
define_battle_manager_method
end
#--------------------------------------------------------------------------
# ○ バトルマネージャメソッドの定義
#--------------------------------------------------------------------------
def define_battle_manager_method
BattleManager.define_method(method(:wait), :wait)
BattleManager.define_method(method(:post_add_battler), :post_add_battler)
BattleManager.define_method(method(:post_remove_battler), :post_remove_battler)
BattleManager.define_method(method(:prev_remove_battler), :prev_remove_battler)
BattleManager.define_method(method(:prev_add_battler), :prev_add_battler)
BattleManager.define_method(method(:process_victory), :process_victory)
BattleManager.define_method(method(:battle_end), :battle_end)
end
#--------------------------------------------------------------------------
# ☆ ステータスウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_status_window create_status_window
def create_status_window
a1_battle_common_sb_create_status_window
post_create_status_window
define_status_window_method
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_status_window
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_status_window_method
@status_window.define_method(method(:refresh_statsu_window), :refresh_statsu_window)
@status_window.define_method(method(:close_status_window), :close_status_window)
@status_window.define_method(method(:open_status_window), :open_status_window)
@status_window.define_method(method(:select_status_window), :select_status_window)
@status_window.define_method(method(:update_status_window), :update_status_window)
@status_window.define_method(method(:dispose_status_window), :dispose_status_window)
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウがリフレッシュされた時の処理
#--------------------------------------------------------------------------
def refresh_statsu_window
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウがクローズされた時の処理
#--------------------------------------------------------------------------
def close_status_window
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウがオープンされた時の処理
#--------------------------------------------------------------------------
def open_status_window
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウがセレクトされた時の処理
#--------------------------------------------------------------------------
def select_status_window(index)
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウが更新された時の処理
#--------------------------------------------------------------------------
def update_status_window
end
#--------------------------------------------------------------------------
# ○ ステータスウィンドウが解放された時の処理
#--------------------------------------------------------------------------
def dispose_status_window
end
#--------------------------------------------------------------------------
# ☆ 情報表示ビューポートの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_info_viewport create_info_viewport
def create_info_viewport
a1_battle_common_sb_create_info_viewport
post_create_info_viewport
end
#--------------------------------------------------------------------------
# ○ 情報表示ビューポート作成の後処理
#--------------------------------------------------------------------------
def post_create_info_viewport
end
#--------------------------------------------------------------------------
# ☆ スキルウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_skill_window create_skill_window
def create_skill_window
a1_battle_common_sb_create_skill_window
post_create_skill_window
define_skill_window_method
end
#--------------------------------------------------------------------------
# ○ スキルウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_skill_window
end
#--------------------------------------------------------------------------
# ○ スキルウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_skill_window_method
@skill_window.define_method(method(:skill_item_window_show), :skill_item_window_show)
@skill_window.define_method(method(:skill_item_window_hide), :skill_item_window_hide)
end
#--------------------------------------------------------------------------
# ☆ アイテムウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_item_window create_item_window
def create_item_window
a1_battle_common_sb_create_item_window
post_create_item_window
define_item_window_method
end
#--------------------------------------------------------------------------
# ○ アイテムウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_item_window
end
#--------------------------------------------------------------------------
# ○ アイテムウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_item_window_method
@item_window.define_method(method(:skill_item_window_show), :skill_item_window_show)
@item_window.define_method(method(:skill_item_window_hide), :skill_item_window_hide)
end
#--------------------------------------------------------------------------
# ○ スキル/アイテムウィンドウが表示された時の処理
#--------------------------------------------------------------------------
def skill_item_window_show
end
#--------------------------------------------------------------------------
# ○ スキル/アイテムウィンドウが非表示になった時の処理
#--------------------------------------------------------------------------
def skill_item_window_hide
end
#--------------------------------------------------------------------------
# ☆ パーティコマンドウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_party_command_window create_party_command_window
def create_party_command_window
a1_battle_common_sb_create_party_command_window
post_create_party_command_window
define_party_command_window_method
define_party_command_window_handle
end
#--------------------------------------------------------------------------
# ○ パーティコマンドウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_party_command_window
end
#--------------------------------------------------------------------------
# ○ パーティコマンドウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_party_command_window_method
end
#--------------------------------------------------------------------------
# ○ パーティコマンドウィンドウハンドルの定義
#--------------------------------------------------------------------------
def define_party_command_window_handle
end
#--------------------------------------------------------------------------
# ☆ アクターウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_actor_window create_actor_window
def create_actor_window
a1_battle_common_sb_create_actor_window
post_create_actor_window
define_actor_window_method
end
#--------------------------------------------------------------------------
# ○ アクターウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_actor_window
end
#--------------------------------------------------------------------------
# ○ アクターウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_actor_window_method
@actor_window.define_method(method(:select_actor), :select_actor)
@actor_window.define_method(method(:select_actor_end), :select_actor_end)
end
#--------------------------------------------------------------------------
# ○ アクターウィンドウをセレクトした時の処理
#--------------------------------------------------------------------------
def select_actor(index)
end
#--------------------------------------------------------------------------
# ○ アクターウィンドウをセレクト終了した時の処理
#--------------------------------------------------------------------------
def select_actor_end
end
#--------------------------------------------------------------------------
# ☆ 敵キャラウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_create_enemy_window create_enemy_window
def create_enemy_window
a1_battle_common_sb_create_enemy_window
post_create_enemy_window
define_enemy_window_method
end
#--------------------------------------------------------------------------
# ○ 敵キャラウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_enemy_window
end
#--------------------------------------------------------------------------
# ○ 敵キャラウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_enemy_window_method
@enemy_window.define_method(method(:select_enemy), :select_enemy)
@enemy_window.define_method(method(:select_enemy_end) ,:select_enemy_end)
end
#--------------------------------------------------------------------------
# ○ 敵キャラウィンドウをセレクトした時の処理
#--------------------------------------------------------------------------
def select_enemy(index)
end
#--------------------------------------------------------------------------
# ○ 敵キャラウィンドウをセレクト終了した時の処理
#--------------------------------------------------------------------------
def select_enemy_end
end
#--------------------------------------------------------------------------
# ☆ アクターコマンドウィンドウの作成
#--------------------------------------------------------------------------
alias a1_battle_common_sb_start_create_actor_command_window create_actor_command_window
def create_actor_command_window
a1_battle_common_sb_start_create_actor_command_window
post_create_actor_command_window
define_actor_command_handle
define_actor_command_window
end
#--------------------------------------------------------------------------
# ○ アクターコマンドウィンドウ作成の後処理
#--------------------------------------------------------------------------
def post_create_actor_command_window
end
#--------------------------------------------------------------------------
# ○ アクターコマンドウィンドウメソッドの定義
#--------------------------------------------------------------------------
def define_actor_command_window
@actor_command_window.define_method(method(:actor_command_open), :actor_command_open)
@actor_command_window.define_method(method(:actor_command_close), :actor_command_close)
@actor_command_window.define_method(method(:actor_command_setup), :actor_command_setup)
end
#--------------------------------------------------------------------------
# ○ アクターコマンドウィンドウハンドルの定義
#--------------------------------------------------------------------------
def define_actor_command_handle
end
#--------------------------------------------------------------------------
# ○ アクターコマンドウィンドウがオープンした時の処理
#--------------------------------------------------------------------------
def actor_command_open
end
#--------------------------------------------------------------------------
# ○ アクターコマンドウィンドウがクローズした時の処理
#--------------------------------------------------------------------------
def actor_command_close
end
#--------------------------------------------------------------------------
# ○ アクターコマンドウィンドウのセットアップ時の処理
#--------------------------------------------------------------------------
def actor_command_setup(actor)
end
#--------------------------------------------------------------------------
# ☆ パーティコマンド選択の開始
#--------------------------------------------------------------------------
alias a1_battle_common_sb_start_party_command_selection start_party_command_selection
def start_party_command_selection
prev_start_party_command_selection
a1_battle_common_sb_start_party_command_selection
post_start_party_command_selection
end
#--------------------------------------------------------------------------
# ○ パーティコマンド選択の開始の前処理
#--------------------------------------------------------------------------
def prev_start_party_command_selection
end
#--------------------------------------------------------------------------
# ○ パーティコマンド選択の開始の後処理
#--------------------------------------------------------------------------
def post_start_party_command_selection
end
#--------------------------------------------------------------------------
# ☆ 次のコマンド入力へ
#--------------------------------------------------------------------------
alias a1_battle_common_sb_next_command next_command
def next_command
prev_next_command
a1_battle_common_sb_next_command
post_next_command
end
#--------------------------------------------------------------------------
# ○ 次のコマンド入力への前処理
#--------------------------------------------------------------------------
def prev_next_command
end
#--------------------------------------------------------------------------
# ○ 次のコマンド入力への後処理
#--------------------------------------------------------------------------
def post_next_command
end
#--------------------------------------------------------------------------
# ☆ 前のコマンド入力へ
#--------------------------------------------------------------------------
alias a1_battle_common_sb_prior_command prior_command
def prior_command
prev_prior_command
a1_battle_common_sb_prior_command
post_prior_command
end
#--------------------------------------------------------------------------
# ○ 前のコマンド入力への前処理
#--------------------------------------------------------------------------
def prev_prior_command
end
#--------------------------------------------------------------------------
# ○ 前のコマンド入力への後処理
#--------------------------------------------------------------------------
def post_prior_command
end
#--------------------------------------------------------------------------
# ☆ ターン開始
#--------------------------------------------------------------------------
alias a1_battle_common_sb_turn_start turn_start
def turn_start
prev_turn_start
a1_battle_common_sb_turn_start
post_turn_start
end
#--------------------------------------------------------------------------
# ○ ターン開始の前処理
#--------------------------------------------------------------------------
def prev_turn_start
end
#--------------------------------------------------------------------------
# ○ ターン開始の後処理
#--------------------------------------------------------------------------
def post_turn_start
end
#--------------------------------------------------------------------------
# ☆ ターン終了
#--------------------------------------------------------------------------
alias a1_battle_common_sb_turn_end turn_end
def turn_end
prev_turn_end
a1_battle_common_sb_turn_end
post_turn_end
end
#--------------------------------------------------------------------------
# ○ ターン終了の前処理
#--------------------------------------------------------------------------
def prev_turn_end
end
#--------------------------------------------------------------------------
# ○ ターン終了の後処理
#--------------------------------------------------------------------------
def post_turn_end
end
#--------------------------------------------------------------------------
# ○ ウィンドウが閉じるまでウェイト
#--------------------------------------------------------------------------
def wait_fot_window_close(window)
update_basic while window.close?
end
#--------------------------------------------------------------------------
# ○ アクターのバトルメンバー取得
#--------------------------------------------------------------------------
def battle_members
@party_battle_members ||= $game_party.battle_members
return @party_battle_members
end
#--------------------------------------------------------------------------
# ○ バトルメンバーの追加の前処理
#--------------------------------------------------------------------------
def prev_add_battler(members)
end
#--------------------------------------------------------------------------
# ○ バトルメンバーの追加後の処理
#--------------------------------------------------------------------------
def post_add_battler(member)
@party_battle_members = $game_party.battle_members
end
#--------------------------------------------------------------------------
# ○ バトルメンバー削除の前処理
#--------------------------------------------------------------------------
def prev_remove_battler(member)
end
#--------------------------------------------------------------------------
# ○ バトルメンバーの削除後の処理
#--------------------------------------------------------------------------
def post_remove_battler
@party_battle_members = $game_party.battle_members
end
#--------------------------------------------------------------------------
# ☆ 戦闘行動の実行
#--------------------------------------------------------------------------
alias a1_battle_common_sb_execute_action execute_action
def execute_action
prev_execute_action
a1_battle_common_sb_execute_action
post_execute_action
end
#--------------------------------------------------------------------------
# ○ 戦闘行動の実行の前処理
#--------------------------------------------------------------------------
def prev_execute_action
@subject.current_action.pre_make_targets
end
#--------------------------------------------------------------------------
# ○ 戦闘行動の実行の後処理
#--------------------------------------------------------------------------
def post_execute_action
@subject.current_action.clear_targets if @subject.current_action
end
#--------------------------------------------------------------------------
# ☆ スキル／アイテムの使用
#--------------------------------------------------------------------------
alias a1_battle_common_sb_use_item use_item
def use_item
prev_use_item
a1_battle_common_sb_use_item
post_use_item
end
#--------------------------------------------------------------------------
# ○ スキル／アイテムの使用の前処理
#--------------------------------------------------------------------------
def prev_use_item
end
#--------------------------------------------------------------------------
# ○ スキル／アイテムの使用の後処理
#--------------------------------------------------------------------------
def post_use_item
end
#--------------------------------------------------------------------------
# ○ 勝利の処理
#--------------------------------------------------------------------------
def process_victory
end
#--------------------------------------------------------------------------
# ○ 戦闘終了
#--------------------------------------------------------------------------
def battle_end(result)
$game_party.all_members.each {|member| init_member_battle_end(member) }
end
#--------------------------------------------------------------------------
# ○ 戦闘終了時のメンバー初期化
#--------------------------------------------------------------------------
def init_member_battle_end(member)
member.current_weapon = nil
member.current_main = nil
end
end
end

复制代码

スクリプト本体

#===========================================================================
# ◆ A1 Scripts ◆
# 戦闘中入れ替え（RGSS3）
#
# バージョン： 1.00 (2012/01/18)
# 作者： A1
# URL　　　　　： http://a1tktk.web.fc2.com/
#---------------------------------------------------------------------------
# 機能：
# ・戦闘中にメンバーを入れ替えます
#---------------------------------------------------------------------------
# 更新履歴　　：2012/01/18 Ver1.00 リリース
#---------------------------------------------------------------------------
# 設置場所
# A1バトル共通スクリプト以下
#
# 必要スクリプト
# A1バトル共通スクリプト
#---------------------------------------------------------------------------
# 使い方
# 導入することで適用されます
#==============================================================================
$imported ||= {}
if $imported["A1_BattleCommonScript"]
$imported["A1_ChangeMember"] = true
old_common_script("戦闘中入れ替え", "3.90") if common_version < 3.90
#==============================================================================
# ■ Window_PartyCommand
#==============================================================================
class Window_MemberChange < Window_Selectable
#--------------------------------------------------------------------------
# ○ オブジェクト初期化
#--------------------------------------------------------------------------
def initialize
@form_actor_window = Window_PersonalStatus.new(0, Graphics.height - 120, 255)
@to_actor_window = Window_PersonalStatus.new(Graphics.width / 2, Graphics.height - 120, 255)
setup_members
width = @battle_members.size * 48 + standard_padding * 2
height = (@all_members.size / @battle_members.size.to_f).ceil * 48 + standard_padding * 2 + 36
super((Graphics.width - width) / 2, (Graphics.height - height) / 2, width, height)
self.y = Graphics.height - @form_actor_window.height - height if self.y + height > Graphics.height - @form_actor_window.height
self.index = 0
@from_actor = -1
self.openness = 0
end
#--------------------------------------------------------------------------
# ○ アクティブ化
#--------------------------------------------------------------------------
def activate
super
refresh
@form_actor_window.actor = @all_members[self.index]
end
#--------------------------------------------------------------------------
# ○ メンバーのセットアップ
#--------------------------------------------------------------------------
def setup_members
@all_members = $game_party.all_members
@battle_members = $game_party.battle_members
end
#--------------------------------------------------------------------------
# ○ 項目の選択
#--------------------------------------------------------------------------
def select(index)
super
@form_actor_window.actor = @all_members[self.index] if @from_actor == -1
@to_actor_window.actor = @all_members[self.index] if @from_actor >= 0
end
#--------------------------------------------------------------------------
# ○ 項目数の取得
#--------------------------------------------------------------------------
def item_max
@all_members.size
end
#--------------------------------------------------------------------------
# ○ 桁数の取得
#--------------------------------------------------------------------------
def col_max
@battle_members.size
end
#--------------------------------------------------------------------------
# ○ リフレッシュ
#--------------------------------------------------------------------------
def refresh
super
draw_horz_line(52)
end
#--------------------------------------------------------------------------
# ○ 水平線の描画
#--------------------------------------------------------------------------
def draw_horz_line(y)
line_y = y + line_height / 2 - 1
contents.fill_rect(0, line_y, contents_width, 2, line_color)
end
#--------------------------------------------------------------------------
# ○ 水平線の色を取得
#--------------------------------------------------------------------------
def line_color
color = normal_color
color.alpha = 128
color
end
#--------------------------------------------------------------------------
# ○ 項目の描画
#--------------------------------------------------------------------------
def draw_item(index)
c_name = member(index).character_name
c_index = member(index).character_index
rect = item_rect(index)
draw_character(c_name, c_index, rect.x + 24, rect.y + 40)
end
#--------------------------------------------------------------------------
# ○ 項目を描画する矩形の取得
#--------------------------------------------------------------------------
def item_rect(index)
rect = Rect.new
rect.width = item_width
rect.height = item_height
rect.x = index % col_max * item_width
rect.y = index / col_max * item_height
rect.y += 24 if index > @battle_members.size - 1
rect
end
#--------------------------------------------------------------------------
# ○ 項目の幅を取得
#--------------------------------------------------------------------------
def item_width
return 48
end
#--------------------------------------------------------------------------
# ○ 項目の高さを取得
#--------------------------------------------------------------------------
def item_height
return 48
end
#--------------------------------------------------------------------------
# ○ ウィンドウ内容の高さを計算
#--------------------------------------------------------------------------
def contents_height
row_max * item_height + 24
end
#--------------------------------------------------------------------------
# ○ 下端パディングの更新
#--------------------------------------------------------------------------
def update_padding_bottom
surplus = (height - standard_padding * 2) % item_height - 24
self.padding_bottom = padding + surplus
end
#--------------------------------------------------------------------------
# ○ メンバーの取得
#--------------------------------------------------------------------------
def member(index)
@all_members[index]
end
#--------------------------------------------------------------------------
# ○ 決定処理の有効状態を取得
#--------------------------------------------------------------------------
def ok_enabled?
return true
end
#--------------------------------------------------------------------------
# ○ 決定ボタンが押されたときの処理
#--------------------------------------------------------------------------
def process_ok
Sound.play_ok
Input.update
return select_start_to_actor if @from_actor == -1
return call_cancel_handler if @from_actor == self.index
change_member if @from_actor >= 0
post_change_member
end
#--------------------------------------------------------------------------
# ○ メンバー入れ替え
#--------------------------------------------------------------------------
def change_member
$game_party.swap_order(@from_actor, self.index)
end
#--------------------------------------------------------------------------
# ○ メンバー入れ替え後の処理
#--------------------------------------------------------------------------
def post_change_member
setup_members
self.index = @from_actor
@form_actor_window.actor = @all_members[self.index]
@from_actor = -1
@to_actor_window.close
refresh
end
#--------------------------------------------------------------------------
# ○ 入れ替え先のアクター選択開始
#--------------------------------------------------------------------------
def select_start_to_actor
@from_actor = self.index
@to_actor_window.open
self.index = self.index < @battle_members.size ? @battle_members.size : 0
@to_actor_window.actor = @all_members[self.index]
end
#--------------------------------------------------------------------------
# ○ 入れ替え元のアクター
#--------------------------------------------------------------------------
def from_actor
@from_actor
end
#--------------------------------------------------------------------------
# ○ オープン
#--------------------------------------------------------------------------
def open
super
@form_actor_window.open
end
#--------------------------------------------------------------------------
# ○ キャンセルハンドラの呼び出し
#--------------------------------------------------------------------------
def call_cancel_handler
super if @from_actor == -1
@from_actor = -1
@to_actor_window.close
@form_actor_window.actor = @all_members[self.index]
activate
end
#--------------------------------------------------------------------------
# ○ クローズ
#--------------------------------------------------------------------------
def close
super
@form_actor_window.close
@to_actor_window.close
end
#--------------------------------------------------------------------------
# ○ フレーム更新
#--------------------------------------------------------------------------
def update
super
@form_actor_window.update
@to_actor_window.update
end
#--------------------------------------------------------------------------
# ○ 解放
#--------------------------------------------------------------------------
def dispose
super
@form_actor_window.dispose
@to_actor_window.dispose
end
end
#==============================================================================
# ■ Window_PartyCommand
#------------------------------------------------------------------------------
# 　バトル画面で、戦うか逃げるかを選択するウィンドウです。
#==============================================================================
class Window_PartyCommand < Window_Command
#--------------------------------------------------------------------------
# ☆ コマンドリストの作成
#--------------------------------------------------------------------------
alias a1_cbm_wpc_make_command_list make_command_list
def make_command_list
a1_cbm_wpc_make_command_list
add_command("入れ替え", :member_change, $game_party.all_members.size > $game_party.max_battle_members)
end
end
#==============================================================================
# ■ Scene_Battle
#------------------------------------------------------------------------------
# 　バトル画面の処理を行うクラスです。
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ☆ 全ウィンドウの作成
#--------------------------------------------------------------------------
alias a1_cbm_wpc_create_all_windows create_all_windows
def create_all_windows
a1_cbm_wpc_create_all_windows
create_member_change_window
end
#--------------------------------------------------------------------------
# ○ 入れ替えウィンドウの作成
#--------------------------------------------------------------------------
def create_member_change_window
@window_member_change = Window_MemberChange.new
@window_member_change.set_handler(:cancel, method(:on_member_change_cancel))
end
#--------------------------------------------------------------------------
# ☆ パーティコマンドウィンドウハンドルの定義
#--------------------------------------------------------------------------
alias a1_cbm_sb_define_party_command_window_handle define_party_command_window_handle
def define_party_command_window_handle
a1_cbm_sb_define_party_command_window_handle
@party_command_window.set_handler(:member_change, method(:command_member_change))
end
#--------------------------------------------------------------------------
# ○ 入れ替え
#--------------------------------------------------------------------------
def command_member_change
@prev_battle_members = $game_party.battle_members
@status_window.close
@party_command_window.close
@window_member_change.open
@window_member_change.activate
end
#--------------------------------------------------------------------------
# ○ 変更したメンバーを取得
#--------------------------------------------------------------------------
def change_diss_members(ret = [])
$game_party.battle_members.each_with_index {|member, i| ret.push(member) if member != @prev_battle_members[i] }
return ret
end
#--------------------------------------------------------------------------
# ○ メンバーチェンジ[キャンセル]
#--------------------------------------------------------------------------
def on_member_change_cancel
@party_command_window.activate
@status_window.refresh
@status_window.open
@party_command_window.open
@window_member_change.close
change_diss_members.each {|member| member.make_actions }
@party_battle_members = $game_party.battle_members
end
end
end

复制代码

��

xuzhengchi · 发表于 2012-3-28 23:12:36

第二个脚本第120行改成true就可以默认锁定一号角色了

帐号		自动登录	找回密码
密码			注册会员

[已经解决] 如何在战斗中整队

评分

点评

点评

点评

点评

点评

评分

贵宾