[XP] The Dark Power: Smocza Krew

[WestGames]

W grze zmieniłem rozmiar charsetów. Do zapowiedzi dodałem nowe screeny, niestety nie widać na nich minimapy, ponieważ... zapomniałem ją włączyć ^^"

[ReetzO]

Według mnie minimapa nie będzie potrzebna, gdyż to nie ABS, chociaż można się uprzeć i ją dać. Akurat ta od squall(a?) jest na prawdę schludnie zrobiona i wcale nie musi przeszkadzać, tylko żeby to miało sens :3

[Soul]

WestGames napisał(a):Gdyby ktoś mógł podrzucić mi jakichś pomysł na Battle System było by świetnie ^^ Nie lubię ABS'a (chyba że prostego w obsłudze i kompatybilnego ze skryptami które używam). Myślę nad jakimś systemem turowym. Albo nad tym którego używa Ayene w Wymiarze X.

Zawsze możesz zrobić system z planowaniem tur, czyli najpierw z góry ustawiasz komendy, a dopiero potem są wykonywane.

Co do gry-ta mieszanka charów niezbyt mi się podoba. Ciekawe jak ten olbrzym zmieścił się w jaskini xD
Szkoda, że nie ma battlersów w walce, przez co wygląda ona trochę pusto, a także napis "Run" lepiej brzmiałby spolszczony.

[WestGames]

Soul odpowiadając na pytania:
chary w większości są takie jak nasza postać (poza rycerstwem)
Troll zmieścił się tam w taki oto sposób:
w grze jest misja pt: "Zasypany troll" XD
w misji trzeba pomóc trollowi wydostać się z zasypanej gruzem jaskini do której tylko człowiek jeszcze może wejść, można też zabić trolla, niestety to ma swoje złe strony np. gdy rozmawiamy z innymi trollami.
A co do walki:
1. Nie mogę znaleść żadnego Battlera do głównej postaci
2. Próbuje naprawić "Run" niestety w RGSS się niezbyt orientuje :/

[ReetzO]

Podaj ten skrypt w [code][./code] tu w temacie (usuń tą kropkę).
Na pewno coś razem pokombinujemy :3

[WestGames]

Oto skrypt:

Kod: (Zaznacz wszystko)

#==============================================================================
# Ś New_Battle
#------------------------------------------------------------------------------
# Compiled By : MakirouAru
#==============================================================================
# �Ľ�Ł�Ľ XRXS_BP 3. ������HP�ń�� ver.1.01 �Ľ�Ł�Ľ
# by fukuyama, �÷�ë �Ý�y

# Battle_End_Recovery
#
# �í�Ź�ă�Ě�ń���������W���[��
#
# Request: stay
# Script: fukuyama
# Test: �m�R�m�q
#
# URL: http://www4.big.or.jp/~fu...nd_Recovery.txt
#

module Battle_End_Recovery

module Scene_Battle_Module

# �ń���Ś�Ď���ĚID
@@recovery_rate_variable_id = nil

# �ń���Ś�Ě�ć�ž
def battle_end_recovery_rate
if @@recovery_rate_variable_id.nil?
@@recovery_rate_variable_id =
$data_system.variables.index '�í�Ź�ă�Ě�ń���Ś'
if @@recovery_rate_variable_id.nil?
@@recovery_rate_variable_id = false
end
end
return 0 unless @@recovery_rate_variable_id
return $game_variables[@@recovery_rate_variable_id]
end

# �í�Ź�ă�Ě�ń������
def battle_end_recovery

# �ń���Ś
recovery_rate = battle_end_recovery_rate

# �ń���Ś�Ď���Ş�O�Č�O�Š�Â�A�N�^�[�Ş�ś�ś�ľ�Ä�˘�é�ę���A�í�Ź�ă�Ě�ń�������đ�s�¤
if recovery_rate != 0 and not actor.dead?

# �p�[�e�B��A�N�^�[������[�v
$game_party.actors.each do |actor|

# ���v�Z
recovery_hp = (actor.maxhp / 100.0 * recovery_rate).truncate
recovery_sp = (actor.maxsp / 100.0 * recovery_rate).truncate

# �Ŕ�Ű�É�ń��
actor.hp += recovery_hp
actor.sp += recovery_sp

# �A�j���[�V�����Ý�č
actor.damage = - recovery_hp
actor.damage_pop = true

end

# �X�e�[�^�X�E�B���h�E�đ�X�V
@status_window.refresh

end
end

end # module Scene_Battle_Module
end # module Battle_End_Recovery

#------------------------------
# �í�Ź�V�[���Ě�Ä�č�`
#------------------------------
class Scene_Battle

# Scene_Battle�p���W���[���đ�C���N���[�h
include Battle_End_Recovery::Scene_Battle_Module

# �ł�Ě�t�F�[�Y�T�J�n�É�Ę�ź�đ�Â�Ż�é
alias battle_end_recovery_original_start_phase5 start_phase5

# �t�F�[�Y�T�J�n�đ�Ä�č�`
def start_phase5

# �í�Ź�ă�Ě�ń�������đ�Ä�Ń�o�ˇ
battle_end_recovery

# �ł�Ě�t�F�[�Y�T�J�n�đ�Ä�Ń�o�ˇ
battle_end_recovery_original_start_phase5

end
end

# Battle_End_Recovery
# �Ľ�Ł�Ľ XRXS_BP10. LEVEL UP!�E�B���h�E �Ľ�Ł�Ľ
# by �÷�ë �Ý�y

$data_system_level_up_se = "" # ���x���A�b�vSE�B""�Ĺ�ł�ľ�B
$data_system_level_up_me = "Audio/ME/007-Fanfare01" # ���x���A�b�vME

#==============================================================================
# �Ą Window_LevelUpWindow
#------------------------------------------------------------------------------
# �@�o�g���I�š���A���x���A�b�v�ľ�˝�ę���É�X�e�[�^�X�đ�\�Ś�ˇ�é�E�B���h�E�Ĺ�ˇ�B
#==============================================================================
class Window_LevelUpWindow < Window_Base
#--------------------------------------------------------------------------
# �� �I�u�W�F�N�g���ú�ť
#--------------------------------------------------------------------------
def initialize(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
super(0, 128, 160, 192)
self.contents = Bitmap.new(width - 32, height - 32)
self.visible = false
refresh(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
end
#--------------------------------------------------------------------------
# �� ���t���b�V��
#--------------------------------------------------------------------------
def refresh(actor, last_lv, up_hp, up_sp, up_str, up_dex, up_agi, up_int)
self.contents.clear
self.contents.font.color = system_color
self.contents.font.name = "Arial"
self.contents.font.size = 14
self.contents.draw_text( 0, 0, 160, 24, "LEVEL UP!!")
self.contents.font.size = 18
self.contents.draw_text( 0, 28, 160, 24, $data_system.words.hp)
self.contents.draw_text( 0, 50, 160, 24, $data_system.words.sp)
self.contents.font.size = 14
self.contents.draw_text( 0, 72, 80, 24, $data_system.words.str)
self.contents.draw_text( 0, 94, 80, 24, $data_system.words.dex)
self.contents.draw_text( 0, 116, 80, 24, $data_system.words.agi)
self.contents.draw_text( 0, 138, 80, 24, $data_system.words.int)
self.contents.draw_text(92, 0, 128, 24, "�¨")
self.contents.draw_text(76, 28, 128, 24, "=")
self.contents.draw_text(76, 50, 128, 24, "=")
self.contents.draw_text(76, 72, 128, 24, "=")
self.contents.draw_text(76, 94, 128, 24, "=")
self.contents.draw_text(76, 116, 128, 24, "=")
self.contents.draw_text(76, 138, 128, 24, "=")
self.contents.font.color = normal_color
self.contents.draw_text( 0, 0, 88, 24, last_lv.to_s, 2)
self.contents.draw_text( 0, 28, 72, 24, "+" + up_hp.to_s, 2)
self.contents.draw_text( 0, 50, 72, 24, "+" + up_sp.to_s, 2)
self.contents.draw_text( 0, 72, 72, 24, "+" + up_str.to_s, 2)
self.contents.draw_text( 0, 94, 72, 24, "+" + up_dex.to_s, 2)
self.contents.draw_text( 0, 116, 72, 24, "+" + up_agi.to_s, 2)
self.contents.draw_text( 0, 138, 72, 24, "+" + up_int.to_s, 2)
self.contents.font.size = 20
self.contents.draw_text( 0, 0, 128, 24, actor.level.to_s, 2)
self.contents.draw_text( 0, 26, 128, 24, actor.maxhp.to_s, 2)
self.contents.draw_text( 0, 48, 128, 24, actor.maxsp.to_s, 2)
self.contents.draw_text( 0, 70, 128, 24, actor.str.to_s, 2)
self.contents.draw_text( 0, 92, 128, 24, actor.dex.to_s, 2)
self.contents.draw_text( 0, 114, 128, 24, actor.agi.to_s, 2)
self.contents.draw_text( 0, 136, 128, 24, actor.int.to_s, 2)
end
end
#==============================================================================
# �Ą Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# �� �Ç�Á�E�ö�J�C���X�^���X�Ď��
#--------------------------------------------------------------------------
attr_accessor :level_up_flags # LEVEL UP!�\�Ś
end
#==============================================================================
# �Ą Game_Battler
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# �� �Ç�Á�E�ö�J�C���X�^���X�Ď��
#--------------------------------------------------------------------------
attr_accessor :exp_gain_ban # EXP������~
#--------------------------------------------------------------------------
# �� �I�u�W�F�N�g���ú�ť
#--------------------------------------------------------------------------
alias xrxs_bp10_initialize initialize
def initialize
@exp_gain_ban = false
xrxs_bp10_initialize
end
#--------------------------------------------------------------------------
# �� �X�e�[�g [EXP �đ�l�ž�Ĺ�Ť�Č�˘] �ť�č
#--------------------------------------------------------------------------
alias xrxs_bp10_cant_get_exp? cant_get_exp?
def cant_get_exp?
if @exp_gain_ban == true
return true
else
return xrxs_bp10_cant_get_exp?
end
end
end
#==============================================================================
# �Ą Scene_Battle
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
# �� �A�t�^�[�o�g���t�F�[�Y�J�n
#--------------------------------------------------------------------------
alias xrxs_bp10_start_phase5 start_phase5
def start_phase5
# EXP �l�ž�Ö�~
for i in 0...$game_party.actors.size
$game_party.actors[i].exp_gain_ban = true
end
xrxs_bp10_start_phase5
# EXP �l�ž�Ö�~�Ě�đ��
for i in 0...$game_party.actors.size
$game_party.actors[i].exp_gain_ban = false
end
# EXP�đ���ú�ť
@exp_gained = 0
for enemy in $game_troop.enemies
# �l�ž EXP�đ�Ç�Á # �G�l�~�[�Ş�B�ę�ó�Ô�Ĺ�Č�˘�ę��
@exp_gained += enemy.exp if not enemy.hidden
end
# �Ý�č
@phase5_step = 0
@exp_gain_actor = -1
# ���U���g�E�B���h�E�đ�\�Ś
@result_window.y -= 64
@result_window.visible = true
# ���x���A�b�v�ť�č�Ö
phase5_next_levelup
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (�A�t�^�[�o�g���t�F�[�Y)
#--------------------------------------------------------------------------
alias xrxs_bp10_update_phase5 update_phase5
def update_phase5
case @phase5_step
when 1
update_phase5_step1
else
xrxs_bp10_update_phase5
# ���x���A�b�v�ľ�Ä�˘�é�ę���Í�­�§�o�g���I�š
battle_end(0) if @levelup_window != nil and @phase5_wait_count <= 0
end
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (�A�t�^�[�o�g���t�F�[�Y 1 : ���x���A�b�v)
#--------------------------------------------------------------------------
def update_phase5_step1
# C �{�^���Ş���ł�ę�˝�ę��
if Input.trigger?(Input::C)
# �E�B���h�E�đ�Â�ś�Ä���Ě�A�N�^�[�Ö
@levelup_window.visible = false if @levelup_window != nil
@status_window.level_up_flags[@exp_gain_actor] = false
phase5_next_levelup
end
end
#--------------------------------------------------------------------------
# �� ���Ě�A�N�^�[�Ě���x���A�b�v�\�Ś�Ö
#--------------------------------------------------------------------------
def phase5_next_levelup
begin
# ���Ě�A�N�^�[�Ö
@exp_gain_actor += 1
# �Ĺ�ă�Ě�A�N�^�[�Ě�ę��
if @exp_gain_actor >= $game_party.actors.size
# �A�t�^�[�o�g���t�F�[�Y�J�n
@phase5_step = 0
return
end
actor = $game_party.actors[@exp_gain_actor]
if actor.cant_get_exp? == false
# �ť�Ý�Ě�\�Í�l�đ�Ű��
last_level = actor.level
last_maxhp = actor.maxhp
last_maxsp = actor.maxsp
last_str = actor.str
last_dex = actor.dex
last_agi = actor.agi
last_int = actor.int
# �o�ą�l�ć�ž�Ě���č�I�u�Ô(�ä
actor.exp += @exp_gained
# �ť�č
if actor.level > last_level
# ���x���A�b�v�ľ�˝�ę��
@status_window.level_up(@exp_gain_actor)
if $data_system_level_up_se != ""
Audio.se_stop
Audio.se_play($data_system_level_up_se)
end
if $data_system_level_up_me != ""
Audio.me_stop
Audio.me_play($data_system_level_up_me)
end
@levelup_window = Window_LevelUpWindow.new(actor, last_level,
actor.maxhp - last_maxhp, actor.maxsp - last_maxsp, actor.str - last_str,
actor.dex - last_dex, actor.agi - last_agi, actor.int - last_int)
@levelup_window.x = 160 * @exp_gain_actor
@levelup_window.visible = true
@phase5_wait_count = 40
@phase5_step = 1
# �X�e�[�^�X�E�B���h�E��t���b�V��
@status_window.refresh
return
end
end
end until false
end
end
# �Ľ�Ł�Ľ XRXS_17. �X���b�v�_���[�W�h�ä�^�ř�Ę�Ę�Ú�×�ť ver.1.51 �Ľ�Ł�Ľ
# by �÷�ë �Ý�y, fukuyama

#==============================================================================
# �Ą Game_Battler
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# �� �X���b�v�_���[�W�Ě�ř�Ę�K�p
#--------------------------------------------------------------------------
alias xrxs_bp7_slip_damage_effect slip_damage_effect
def slip_damage_effect
# ���l�Ě���ú�ť
slip_damage_percent = 0
slip_damage_plus = 0
# �ť�Ý�t�Á�ł�ę�Ä�˘�é�X�e�[�g�Ě���Š�ç�X���b�v�_���[�W�L�č�Ě���m�đ�T�ˇ
for i in @states
if $data_states[i].slip_damage
# �ť�Ě�X�e�[�g�Ş���Á�Ä�˘�é�X���b�v�_���[�W�Ě
# Lv�v���X�X�e�[�g�Ü�˝�ÍLv�}�C�i�X�X�e�[�g�đ�ť�č�B
for j in $data_states[i].plus_state_set
if $data_states[j] != nil
if $data_states[j].name =~ /^�X���b�v([0-9]+)(%|��)/
slip_damage_percent += $1.to_i
elsif $data_states[j].name =~ /^�X���b�v([0-9]+)$/
slip_damage_plus += $1.to_i
end
end
end
for j in $data_states[i].minus_state_set
if $data_states[j] != nil
if $data_states[j].name =~ /^�X���b�v([0-9]+)(%|��)/
slip_damage_percent -= $1.to_i
elsif $data_states[j].name =~ /^�X���b�v([0-9]+)$/
slip_damage_plus -= $1.to_i
end
end
end
end
end
if slip_damage_percent == 0 and slip_damage_plus == 0
xrxs_bp7_slip_damage_effect
else
# �h�ď�Ş�X���b�v�h�ä�Ş� �é�ę���đ�ť�č
for i in [@armor1_id, @armor2_id, @armor3_id, @armor4_id]
armor = $data_armors[i]
next if armor == nil
for j in armor.guard_state_set
if $data_states[j] != nil
if $data_states[j].name =~ /^�X���b�v([0-9]+)(%|��)/
if slip_damage_percent > 0
slip_damage_percent = [slip_damage_percent - $1.to_i, 0].max
end
end
if $data_states[j].name =~ /^�X���b�v([0-9]+)$/
if slip_damage_percent > 0
slip_damage_plus = [slip_damage_plus - $1.to_i, 0].max
end
end
end
end
end
# �_���[�W�đ�Ý�č
self.damage = self.maxhp * slip_damage_percent / 100 + slip_damage_plus
# ��U
if self.damage.abs > 0
amp = [self.damage.abs * 15 / 100, 1].max
self.damage += rand(amp+1) + rand(amp+1) - amp
end
# HP �Š�ç�_���[�W�đ�¸�Z
self.hp -= self.damage
# ���\�b�h�I�š
return true
end
end
end
# �Ľ�Ł�Ľ XRXS_BP 1. CP�§�ą�ü ver.15 �Ľ�Ł�Ľ
# by �÷�ë �Ý�y, �a�ó, Jack-R

#==============================================================================
# �Ą Scene_Battle_CP
#==============================================================================
class Scene_Battle_CP
#--------------------------------------------------------------------------
# �� �ö�J�C���X�^���X�Ď��
#--------------------------------------------------------------------------
attr_accessor :stop # CP�Á�Z�X�g�b�v
#----------------------------------------------------------------------------
# �� �I�u�W�F�N�g�Ě���ú�ť
#----------------------------------------------------------------------------
def initialize
@battlers = []
@cancel = false
@agi_total = 0
# �z�ń @count_battlers �đ���ú�ť
@count_battlers = []
# �G�l�~�[�đ�z�ń @count_battlers �É�Ç�Á
for enemy in $game_troop.enemies
@count_battlers.push(enemy)
end
# �A�N�^�[�đ�z�ń @count_battlers �É�Ç�Á
for actor in $game_party.actors
@count_battlers.push(actor)
end
for battler in @count_battlers
@agi_total += battler.agi
end
for battler in @count_battlers
battler.cp = [[65535 * (rand(15) + 85) / 100 * battler.agi / @agi_total * 4, 0].max, 65535].min
end
end
#----------------------------------------------------------------------------
# �� CP�J�E���g��J�n
#----------------------------------------------------------------------------
def start
if @cp_thread != nil then
return
end
@cancel = false
@stop = false
# �ą�ą�Š�ç�X���b�h
@cp_thread = Thread.new do
while @cancel != true
if @stop != true
self.update # �X�V
sleep(0.05)
end
end
end
# �ą�ą�Ü�Ĺ�X���b�h
end
#----------------------------------------------------------------------------
# �� CP�J�E���g�A�b�v
#----------------------------------------------------------------------------
def update
if @count_battlers != nil then
for battler in @count_battlers
# �s�Ž�o���Č�Ż�ę�Î�ł��
if battler.dead? == true #or battler.movable? == false then
battler.cp = 0
next
end
# �ą�ą�Ě 1.3�đ�Ď�Ś�é�ą�Ć�Ĺ�Ť�X�s�[�h�đ�Ď�X�Â�\�B�˝�ž�ľ�Ź���_�Í�g�p�ˇ�é�ą�Ć�B
battler.cp = [[battler.cp + 1.3 * 4096 * battler.agi / @agi_total, 0].max, 65535].min
end
end
end
#----------------------------------------------------------------------------
# �� CP�J�E���g��J�n
#----------------------------------------------------------------------------
def stop
@cancel = true
if @cp_thread != nil then
@cp_thread.join
@cp_thread = nil
end
end
end
#==============================================================================
# �Ą Game_Battler
#==============================================================================
class Game_Battler
attr_accessor :now_guarding # �ť�Ý�h�ä���t���O
attr_accessor :cp # �ť�ÝCP
attr_accessor :slip_state_update_ban # �X���b�v�E�X�e�[�g�Š�Ž�����Ě�Ö�~
#--------------------------------------------------------------------------
# �� �R�}���h�ü�Í�Â�\�ť�č
#--------------------------------------------------------------------------
def inputable?
return (not @hidden and restriction <= 1 and @cp >=65535)
end
#--------------------------------------------------------------------------
# �� �X�e�[�g [�X���b�v�_���[�W] �ť�č
#--------------------------------------------------------------------------
alias xrxs_bp1_slip_damage? slip_damage?
def slip_damage?
return false if @slip_state_update_ban
return xrxs_bp1_slip_damage?
end
#--------------------------------------------------------------------------
# �� �X�e�[�g�Š�R�đ�� (�^�[���˛�Ć�É�Ä�Ń�o�ľ)
#--------------------------------------------------------------------------
alias xrxs_bp1_remove_states_auto remove_states_auto
def remove_states_auto
return if @slip_state_update_ban
xrxs_bp1_remove_states_auto
end
end
#==============================================================================
# �Ą Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# �� �Z�b�g�A�b�v
#--------------------------------------------------------------------------
alias xrxs_bp1_setup setup
def setup(actor_id)
xrxs_bp1_setup(actor_id)
@hate = 100 # init-value is 100
@cp = 0
@now_guarding = false
@slip_state_update_ban = false
end
end
#==============================================================================
# �Ą Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# �� �I�u�W�F�N�g���ú�ť
#--------------------------------------------------------------------------
alias xrxs_bp1_initialize initialize
def initialize(troop_id, member_index)
xrxs_bp1_initialize(troop_id, member_index)
@hate = 100 # init-value is 100
@cp = 0
@now_guarding = false
@slip_state_update_ban = false
end
end
#==============================================================================
# �Ą Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# �� �ö�J�C���X�^���X�Ď��
#--------------------------------------------------------------------------
attr_accessor :update_cp_only # CP���[�^�[����X�V
#--------------------------------------------------------------------------
# �� �I�u�W�F�N�g���ú�ť
#--------------------------------------------------------------------------
alias xrxs_bp1_initialize initialize
def initialize
@update_cp_only = false
xrxs_bp1_initialize
end
#--------------------------------------------------------------------------
# �� ���t���b�V��
#--------------------------------------------------------------------------
alias xrxs_bp1_refresh refresh
def refresh
if @update_cp_only == false
xrxs_bp1_refresh
end
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
actor_x = i * 160 + 4
draw_actor_cp_meter(actor, actor_x, 96, 120, 0)
end
end
#--------------------------------------------------------------------------
# �� CP���[�^�[ �Ě�`�ć
#--------------------------------------------------------------------------
def draw_actor_cp_meter(actor, x, y, width = 156, type = 0)
self.contents.font.color = system_color
self.contents.fill_rect(x-1, y+27, width+2,6, Color.new(0, 0, 0, 255))
if actor.cp == nil
actor.cp = 0
end
w = width * [actor.cp,65535].min / 65535
self.contents.fill_rect(x, y+28, w,1, Color.new(255, 255, 128, 255))
self.contents.fill_rect(x, y+29, w,1, Color.new(255, 255, 0, 255))
self.contents.fill_rect(x, y+30, w,1, Color.new(192, 192, 0, 255))
self.contents.fill_rect(x, y+31, w,1, Color.new(128, 128, 0, 255))
end
end
#==============================================================================
# �Ą Scene_Battle
#==============================================================================
class Scene_Battle
# �ą�ą�É�ř�Ę�š�đ�Ý�č�ˇ�é�Ć�A�A�N�^�[�R�}���h�Ş�|�b�v�ľ�˝�Ć�Ť�É�ř�Ę�š�đ�Ä�ś
$data_system_command_up_se = ""
#--------------------------------------------------------------------------
# �� �o�g���I�š
# result : ���Ę (0:���� 1:�s�k 2:�Ś��)
#--------------------------------------------------------------------------
alias xrxs_bp1_battle_end battle_end
def battle_end(result)
# CP�J�E���g�â�~
@cp_thread.stop
xrxs_bp1_battle_end(result)
end
#--------------------------------------------------------------------------
# �� �v���o�g���t�F�[�Y�J�n
#--------------------------------------------------------------------------
alias xrxs_bp1_start_phase1 start_phase1
def start_phase1
@agi_total = 0
@cp_thread = Scene_Battle_CP.new
# �A�N�^�[�R�}���h�E�B���h�E�đ�Ä�ě�Ź
s1 = $data_system.words.attack
s2 = $data_system.words.skill
s3 = $data_system.words.guard
s4 = $data_system.words.item
@actor_command_window = Window_Command.new(160, [s1, s2, s3, s4, "Run"])
@actor_command_window.y = 128
@actor_command_window.back_opacity = 160
@actor_command_window.active = false
@actor_command_window.visible = false
@actor_command_window.draw_item(4, $game_temp.battle_can_escape ? @actor_command_window.normal_color : @actor_command_window.disabled_color)
xrxs_bp1_start_phase1
end
#--------------------------------------------------------------------------
# �� �p�[�e�B�R�}���h�t�F�[�Y�J�n
#--------------------------------------------------------------------------
alias xrxs_bp1_start_phase2 start_phase2
def start_phase2
xrxs_bp1_start_phase2
@party_command_window.active = false
@party_command_window.visible = false
# ���Ö
start_phase3
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (�p�[�e�B�R�}���h�t�F�[�Y)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase2 update_phase2
def update_phase2
# C �{�^���Ş���ł�ę�˝�ę��
if Input.trigger?(Input::C)
# �p�[�e�B�R�}���h�E�B���h�E�Ě�J�[�\���Ę�u�Ĺ�Ş�ň
case @party_command_window.index
when 0 # ��
# ���č SE �đ���t
$game_system.se_play($data_system.decision_se)
@cp_thread.start
# �A�N�^�[�R�}���h�t�F�[�Y�J�n
start_phase3
end
return
end
xrxs_bp1_update_phase2
end
#--------------------------------------------------------------------------
# �� ���Ě�A�N�^�[�Ě�R�}���h�ü�Í�Ö
#--------------------------------------------------------------------------
def phase3_next_actor
# ���[�v
begin
# �A�N�^�[�Ě�ž�Ĺ�G�t�F�N�g OFF
if @active_battler != nil
@active_battler.blink = false
end
# �Ĺ�ă�Ě�A�N�^�[�Ě�ę��
if @actor_index == $game_party.actors.size-1
# ���C���t�F�[�Y�J�n
@cp_thread.start
start_phase4
return
end
# �A�N�^�[�Ě�C���f�b�N�X�đ�i�ß�é
@actor_index += 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
if @active_battler.inputable? == false
@active_battler.current_action.kind = -1
end
# �A�N�^�[�Ş�R�}���h�ü�Í�đ�ó�Ż�t�Ż�Č�˘�ó�Ô�Č�ç�ŕ�¤�ę�x
end until @active_battler.inputable?
@cp_thread.stop
# �A�N�^�[�R�}���h�E�B���h�E�đ�Z�b�g�A�b�v
@active_battler.now_guarding = false
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# �� �O�Ě�A�N�^�[�Ě�R�}���h�ü�Í�Ö
#--------------------------------------------------------------------------
def phase3_prior_actor
# ���[�v
begin
# �A�N�^�[�Ě�ž�Ĺ�G�t�F�N�g OFF
if @active_battler != nil
@active_battler.blink = false
end
# �����A�N�^�[���
if @actor_index == 0
# �Ĺ���Ö�ß�é
start_phase3
return
end
# �A�N�^�[�Ě�C���f�b�N�X�đ�ß�ˇ
@actor_index -= 1
@active_battler = $game_party.actors[@actor_index]
@active_battler.blink = true
# �A�N�^�[�Ş�R�}���h�ü�Í�đ�ó�Ż�t�Ż�Č�˘�ó�Ô�Č�ç�ŕ�¤�ę�x
end until @active_battler.inputable?
@cp_thread.stop
# �A�N�^�[�R�}���h�E�B���h�E�đ�Z�b�g�A�b�v
@active_battler.now_guarding = false
phase3_setup_command_window
end
#--------------------------------------------------------------------------
# �� �A�N�^�[�R�}���h�E�B���h�E��Z�b�g�A�b�v
#--------------------------------------------------------------------------
alias xrxs_bp1_phase3_setup_command_window phase3_setup_command_window
def phase3_setup_command_window
# �ř�Ę�š�Ě�Ä�ś
Audio.se_play($data_system_command_up_se) if $data_system_command_up_se != ""
# �ß�ˇ
xrxs_bp1_phase3_setup_command_window
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (�A�N�^�[�R�}���h�t�F�[�Y : �î�{�R�}���h)
#--------------------------------------------------------------------------
alias xrxs_bsp1_update_phase3_basic_command update_phase3_basic_command
def update_phase3_basic_command
# C �{�^���Ş���ł�ę�˝�ę��
if Input.trigger?(Input::C)
# �A�N�^�[�R�}���h�E�B���h�E�Ě�J�[�\���Ę�u�Ĺ�Ş�ň
case @actor_command_window.index
when 4 # �Ś�°�é
if $game_temp.battle_can_escape
# ���č SE �đ���t
$game_system.se_play($data_system.decision_se)
# �A�N�V�����đ�Ý�č
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 4
# ���Ě�A�N�^�[�Ě�R�}���h�ü�Í�Ö
phase3_next_actor
else
# �u�U�[ SE ��t
$game_system.se_play($data_system.buzzer_se)
end
return
end
end
xrxs_bsp1_update_phase3_basic_command
end
#--------------------------------------------------------------------------
# �� ���C���t�F�[�Y�J�n
#--------------------------------------------------------------------------
alias xrxs_bp1_start_phase4 start_phase4
def start_phase4
xrxs_bp1_start_phase4
# �G�l�~�[�A�N�V������
for enemy in $game_troop.enemies
if enemy.cp < 65535
enemy.current_action.clear
enemy.current_action.kind = -1 # �^�[���ň�Î�ľ�B
next
end
enemy.make_action
end
# �s�Ž�����ě�Ź
make_action_orders
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (���C���t�F�[�Y �X�e�b�v 1 : �A�N�V�������ő)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step1 update_phase4_step1
def update_phase4_step1
# ���ú�ť
@phase4_act_continuation = 0
# ���s�ť�č
if judge
@cp_thread.stop
# �����Ü�˝�Í�s�k�Ě�ę�� : ���\�b�h�I�š
return
end
# �˘�s�Ž�o�g���[�z�ń�Ě�ć�Ş�Š�ç�ć�ž
@active_battler = @action_battlers[0]
# �X�e�[�^�X�X�V�đCP�ž�Ż�É�Ŕ�č�B
@status_window.update_cp_only = true
# �X�e�[�g�X�V�đ�Ö�~�B
@active_battler.slip_state_update_ban = true if @active_battler != nil
# �ß�ˇ
xrxs_bp1_update_phase4_step1
# �Ö�~�đ�đ��
@status_window.update_cp_only = false
@active_battler.slip_state_update_ban = false if @active_battler != nil
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (���C���t�F�[�Y �X�e�b�v 2 : �A�N�V�����J�n)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step2 update_phase4_step2
def update_phase4_step2
# �­�§�A�N�V�����Ĺ�Č�Ż�ę�Î
unless @active_battler.current_action.forcing
# CP�Ş�Ť�č�Ä�˘�Č�˘�ę��
if @phase4_act_continuation == 0 and @active_battler.cp < 65535
@phase4_step = 6
return
end
# �§�ń�Ş [�G�đ�Ę�í�U���ˇ�é] �Š [�Ą�ű�đ�Ę�í�U���ˇ�é] �Ě�ę��
if @active_battler.restriction == 2 or @active_battler.restriction == 3
# �A�N�V�����É�U���đ�Ý�č
@active_battler.current_action.kind = 0
@active_battler.current_action.basic = 0
end
# �§�ń�Ş [�s�Ž�Ĺ�Ť�Č�˘] �Ě�ę��
if @active_battler.restriction == 4
# �A�N�V�����­�§�Î�Ű�Ě�o�g���[�đ�N���A
$game_temp.forcing_battler = nil
if @phase4_act_continuation == 0 and @active_battler.cp >= 65535
# �X�e�[�g�Š�R�đ��
@active_battler.remove_states_auto
# CP�Á�ď
@active_battler.cp = [(@active_battler.cp - 65535),0].max
# �X�e�[�^�X�E�B���h�E��t���b�V��
@status_window.refresh
end
# �X�e�b�v 1 ���s
@phase4_step = 1
return
end
end
# �A�N�V�����Ě�í�Ę�Ĺ�Ş�ň
case @active_battler.current_action.kind
when 0
# �U��Ľ�h�ä�E�Ś�°�é�E�˝�ŕ�ľ�Č�˘���Ě�¤�Ę�Á�ďCP
@active_battler.cp -= 0 if @phase4_act_continuation == 0
when 1
# �X�L���g�p���Ě�Á�ďCP
@active_battler.cp -= 65535 if @phase4_act_continuation == 0
when 2
# �A�C�e���g�p���Ě�Á�ďCP
@active_battler.cp -= 65535 if @phase4_act_continuation == 0
when -1
# CP�Ş�­�Ü�Á�Ä�˘�Č�˘
@phase4_step = 6
return
end
# CP�Á�Z�đ�ę���â�~�ˇ�é
@cp_thread.stop = true
# �X�e�[�g�Š�R�đ��
@active_battler.remove_states_auto
xrxs_bp1_update_phase4_step2
end
#--------------------------------------------------------------------------
# �� �î�{�A�N�V���� ���Ę�ě�Ź
#--------------------------------------------------------------------------
alias xrxs_bp1_make_basic_action_result make_basic_action_result
def make_basic_action_result
# �U�����
if @active_battler.current_action.basic == 0 and @phase4_act_continuation == 0
@active_battler.cp -= 65535 # �U�����ĚCP�Á�ď
end
# �h�ä�Ě�ę��
if @active_battler.current_action.basic == 1 and @phase4_act_continuation == 0
@active_battler.cp -= 32767 # �h�ä���ĚCP�Á�ď
end
# �G�Ě�Ś�°�é�Ě�ę��
if @active_battler.is_a?(Game_Enemy) and
@active_battler.current_action.basic == 2 and @phase4_act_continuation == 0
@active_battler.cp -= 65535 # �Ś�����ĚCP�Á�ď
end
# �˝�ŕ�ľ�Č�˘�Ě�ę��
if @active_battler.current_action.basic == 3 and @phase4_act_continuation == 0
@active_battler.cp -= 32767 # �˝�ŕ�ľ�Č�˘���ĚCP�Á�ď
end
# �Ś�°�é�Ě�ę��
if @active_battler.current_action.basic == 4 and @phase4_act_continuation == 0
@active_battler.cp -= 65535 # �Ś�����ĚCP�Á�ď
# �Ś���Â�\�Ĺ�Í�Č�˘�ę��
if $game_temp.battle_can_escape == false
# �u�U�[ SE ��t
$game_system.se_play($data_system.buzzer_se)
return
end
# ���č SE �đ���t
$game_system.se_play($data_system.decision_se)
# �Ś������
update_phase2_escape
return
end
xrxs_bp1_make_basic_action_result
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (���C���t�F�[�Y �X�e�b�v 5 : �_���[�W�\�Ś)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step5 update_phase4_step5
def update_phase4_step5
# �X���b�v�_���[�W
if @active_battler.hp > 0 and @active_battler.slip_damage?
@active_battler.slip_damage_effect
@active_battler.damage_pop = true
end
xrxs_bp1_update_phase4_step5
end
#--------------------------------------------------------------------------
# �� �t���[���X�V (���C���t�F�[�Y �X�e�b�v 6 : ���t���b�V��)
#--------------------------------------------------------------------------
alias xrxs_bp1_update_phase4_step6 update_phase4_step6
def update_phase4_step6
# CP�Á�Z�đ�Ä�J�ˇ�é
@cp_thread.stop = false
# �w���v�E�B���h�E�đ�B�ˇ
@help_window.visible = false
xrxs_bp1_update_phase4_step6
end
end
# �Ľ�Ł�Ľ XRXS_BP 7. �o�g���X�e�[�^�X�E�N���A�f�U�C�� ver.1.02 �Ľ�Ł�Ľ
# by �÷�ë �Ý�y, TOMY

#==============================================================================
# �Ą Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Base
#--------------------------------------------------------------------------
# �� �ö�J�C���X�^���X�Ď��
#--------------------------------------------------------------------------
attr_accessor :update_cp_only # CP���[�^�[����X�V
#--------------------------------------------------------------------------
# �� �I�u�W�F�N�g���ú�ť
#--------------------------------------------------------------------------
alias xrxs_bp7_initialize initialize
def initialize
xrxs_bp7_initialize
# �ŤFull-View�Ě�ę���Í�ş�ń�s�Ě # �đ�Á�ľ�Ä�­�ž�ł�˘�B
#self.opacity = 0
#self.back_opacity = 0
end
#--------------------------------------------------------------------------
# �� ���t���b�V��
#--------------------------------------------------------------------------
alias xrxs_bp7_refresh refresh
def refresh
if @update_cp_only
xrxs_bp7_refresh
return
end
# �`�Ę�đ�Ö�~�ľ�Č�Ş�ç�ß�ˇ
@draw_ban = true
xrxs_bp7_refresh
# �`�Ę�Ě�Ö�~�đ�đ��
@draw_ban = false
# �`�Ę�đ�J�n
@item_max = $game_party.actors.size
for i in 0...$game_party.actors.size
actor = $game_party.actors[i]
actor_x = i * 160 + 21
# �ŕ�s�L�����O���t�B�b�N�Ě�`�Ę
draw_actor_graphic(actor, actor_x - 9, 116)
# HP/SP���[�^�[�Ě�`�Ę
draw_actor_hp_meter_line(actor, actor_x, 72, 96, 12)
draw_actor_sp_meter_line(actor, actor_x, 104, 96, 12)
# HP���l�Ě�`�Ę
self.contents.font.size = 24 # HP/SP���l�Ě�ś���Ě�ĺ�Ť�ł
self.contents.font.color = actor.hp == 0 ? knockout_color :
actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
draw_shadow_text(actor_x-2, 58, 96, 24, actor.hp.to_s, 2)
# SP���l�Ě�`�Ę
self.contents.font.color = actor.sp == 0 ? knockout_color :
actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
draw_shadow_text(actor_x-2, 90, 96, 24, actor.sp.to_s, 2)
# �p�ę�uHP�v�Ć�p�ę�uSP�v�Ě�`�Ę
self.contents.font.size = 12 # �p�ę�uHP/SP�v�Ě�ś���Ě�ĺ�Ť�ł
self.contents.font.color = system_color # �p�ę�uHP/SP�v�Ě�ś���Ě�F
draw_shadow_text(actor_x, 60, 96, 12, $data_system.words.hp)
draw_shadow_text(actor_x, 92, 96, 12, $data_system.words.sp)

draw_actor_state(actor, actor_x, 100)
end
end
end
#==============================================================================
# �Ą Window_Base
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# �� HP���[�^�[ �Ě�`�ć
#--------------------------------------------------------------------------
def draw_actor_hp_meter_line(actor, x, y, width = 156, height = 4)
w = width * actor.hp / actor.maxhp
hp_color_1 = Color.new(255, 0, 0, 192)
hp_color_2 = Color.new(255, 255, 0, 192)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#--------------------------------------------------------------------------
# �� SP���[�^�[ �Ě�`�ć
#--------------------------------------------------------------------------
def draw_actor_sp_meter_line(actor, x, y, width = 156, height = 4)
w = width * actor.sp / actor.maxsp
hp_color_1 = Color.new( 0, 0, 255, 192)
hp_color_2 = Color.new( 0, 255, 255, 192)
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
x -= 1
y += (height/4).floor
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).ceil , Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).ceil , hp_color_2)
x -= 1
y += (height/4).ceil
self.contents.fill_rect(x+8, y+4, width, (height/4).floor, Color.new(0, 0, 0, 128))
draw_line(x, y, x + w, y, hp_color_1, (height/4).floor, hp_color_2)
end
#--------------------------------------------------------------------------
# �� �ź�O�Ě�`�ć
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_name draw_actor_name
def draw_actor_name(actor, x, y)
xrxs_bp7_draw_actor_name(actor, x, y) if @draw_ban != true
end
#--------------------------------------------------------------------------
# �� �X�e�[�g�Ě�`�ć
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_state draw_actor_state
def draw_actor_state(actor, x, y, width = 120)
xrxs_bp7_draw_actor_state(actor, x, y, width) if @draw_ban != true
end
#--------------------------------------------------------------------------
# �� HP �Ě�`�ć
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_hp draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
xrxs_bp7_draw_actor_hp(actor, x, y, width) if @draw_ban != true
end
#--------------------------------------------------------------------------
# �� SP �Ě�`�ć
#--------------------------------------------------------------------------
alias xrxs_bp7_draw_actor_sp draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
xrxs_bp7_draw_actor_sp(actor, x, y, width) if @draw_ban != true
end
end
#==============================================================================
# �� �O�����C�u����
#==============================================================================
class Window_Base
#--------------------------------------------------------------------------
# �� ���C���`�ć by �÷�ë �Ý�y
#--------------------------------------------------------------------------
def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1, end_color = start_color)
# �`�Ę���Ł�Ě�v�Z�B�ĺ�Ť�ß�É�ź�p���Ě�ˇ�ł�B
distance = (start_x - end_x).abs + (start_y - end_y).abs
# �`��J�n
if end_color == start_color
for i in 1..distance
x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
self.contents.fill_rect(x, y, width, width, start_color)
end
else
for i in 1..distance
x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
r = start_color.red * (distance-i)/distance + end_color.red * i/distance
g = start_color.green * (distance-i)/distance + end_color.green * i/distance
b = start_color.blue * (distance-i)/distance + end_color.blue * i/distance
a = start_color.alpha * (distance-i)/distance + end_color.alpha * i/distance
self.contents.fill_rect(x, y, width, width, Color.new(r, g, b, a))
end
end
end

#--------------------------------------------------------------------------
# �� �e�ś���`�ć by TOMY
#--------------------------------------------------------------------------
def draw_shadow_text(x, y, width, height, string, align = 0)
# �ł�Ě�F�đ�Ű�ś�ľ�Ä�¨�­
color = self.contents.font.color.dup
# �����Ĺ�e�`�ć
self.contents.font.color = Color.new(0, 0, 0)
self.contents.draw_text(x + 2, y + 2, width, height, string, align)
# �ł�Ě�F�É�ß�ľ�Ä�`�ć
self.contents.font.color = color
self.contents.draw_text(x, y, width, height, string, align)
end
end

[ReetzO]

Zajrzałem sobie do XP-ka i znalazłem, gdzie można zmienić nazwę ucieczki w walce.
W skrypcie wszystkie opisy po chińsku, żadnego Run nie znalazłem.
Spróbuj podmienić Scene_Battle 4 na ten kod:

Kod: (Zaznacz wszystko)

#==============================================================================
# ** Scene_Battle (part 4)
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle
  #--------------------------------------------------------------------------
  # * Start Main Phase
  #--------------------------------------------------------------------------
  def start_phase4
    # Shift to phase 4
    @phase = 4
    # Turn count
    $game_temp.battle_turn += 1
    # Search all battle event pages
    for index in 0...$data_troops[@troop_id].pages.size
      # Get event page
      page = $data_troops[@troop_id].pages[index]
      # If this page span is [turn]
      if page.span == 1
        # Clear action completed flags
        $game_temp.battle_event_flags[index] = false
      end
    end
    # Set actor as unselectable
    @actor_index = -1
    @active_battler = nil
    # Enable party command window
    @party_command_window.active = false
    @party_command_window.visible = false
    # Disable actor command window
    @actor_command_window.active = false
    @actor_command_window.visible = false
    # Set main phase flag
    $game_temp.battle_main_phase = true
    # Make enemy action
    for enemy in $game_troop.enemies
      enemy.make_action
    end
    # Make action orders
    make_action_orders
    # Shift to step 1
    @phase4_step = 1
  end
  #--------------------------------------------------------------------------
  # * Make Action Orders
  #--------------------------------------------------------------------------
  def make_action_orders
    # Initialize @action_battlers array
    @action_battlers = []
    # Add enemy to @action_battlers array
    for enemy in $game_troop.enemies
      @action_battlers.push(enemy)
    end
    # Add actor to @action_battlers array
    for actor in $game_party.actors
      @action_battlers.push(actor)
    end
    # Decide action speed for all
    for battler in @action_battlers
      battler.make_action_speed
    end
    # Line up action speed in order from greatest to least
    @action_battlers.sort! {|a,b|
      b.current_action.speed - a.current_action.speed }
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase)
  #--------------------------------------------------------------------------
  def update_phase4
    case @phase4_step
    when 1
      update_phase4_step1
    when 2
      update_phase4_step2
    when 3
      update_phase4_step3
    when 4
      update_phase4_step4
    when 5
      update_phase4_step5
    when 6
      update_phase4_step6
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 1 : action preparation)
  #--------------------------------------------------------------------------
  def update_phase4_step1
    # Hide help window
    @help_window.visible = false
    # Determine win/loss
    if judge
      # If won, or if lost : end method
      return
    end
    # If an action forcing battler doesn't exist
    if $game_temp.forcing_battler == nil
      # Set up battle event
      setup_battle_event
      # If battle event is running
      if $game_system.battle_interpreter.running?
        return
      end
    end
    # If an action forcing battler exists
    if $game_temp.forcing_battler != nil
      # Add to head, or move
      @action_battlers.delete($game_temp.forcing_battler)
      @action_battlers.unshift($game_temp.forcing_battler)
    end
    # If no actionless battlers exist (all have performed an action)
    if @action_battlers.size == 0
      # Start party command phase
      start_phase2
      return
    end
    # Initialize animation ID and common event ID
    @animation1_id = 0
    @animation2_id = 0
    @common_event_id = 0
    # Shift from head of actionless battlers
    @active_battler = @action_battlers.shift
    # If already removed from battle
    if @active_battler.index == nil
      return
    end
    # Slip damage
    if @active_battler.hp > 0 and @active_battler.slip_damage?
      @active_battler.slip_damage_effect
      @active_battler.damage_pop = true
    end
    # Natural removal of states
    @active_battler.remove_states_auto
    # Refresh status window
    @status_window.refresh
    # Shift to step 2
    @phase4_step = 2
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 2 : start action)
  #--------------------------------------------------------------------------
  def update_phase4_step2
    # If not a forcing action
    unless @active_battler.current_action.forcing
      # If restriction is [normal attack enemy] or [normal attack ally]
      if @active_battler.restriction == 2 or @active_battler.restriction == 3
        # Set attack as an action
        @active_battler.current_action.kind = 0
        @active_battler.current_action.basic = 0
      end
      # If restriction is [cannot perform action]
      if @active_battler.restriction == 4
        # Clear battler being forced into action
        $game_temp.forcing_battler = nil
        # Shift to step 1
        @phase4_step = 1
        return
      end
    end
    # Clear target battlers
    @target_battlers = []
    # Branch according to each action
    case @active_battler.current_action.kind
    when 0  # basic
      make_basic_action_result
    when 1  # skill
      make_skill_action_result
    when 2  # item
      make_item_action_result
    end
    # Shift to step 3
    if @phase4_step == 2
      @phase4_step = 3
    end
  end
  #--------------------------------------------------------------------------
  # * Make Basic Action Results
  #--------------------------------------------------------------------------
  def make_basic_action_result
    # If attack
    if @active_battler.current_action.basic == 0
      # Set anaimation ID
      @animation1_id = @active_battler.animation1_id
      @animation2_id = @active_battler.animation2_id
      # If action battler is enemy
      if @active_battler.is_a?(Game_Enemy)
        if @active_battler.restriction == 3
          target = $game_troop.random_target_enemy
        elsif @active_battler.restriction == 2
          target = $game_party.random_target_actor
        else
          index = @active_battler.current_action.target_index
          target = $game_party.smooth_target_actor(index)
        end
      end
      # If action battler is actor
      if @active_battler.is_a?(Game_Actor)
        if @active_battler.restriction == 3
          target = $game_party.random_target_actor
        elsif @active_battler.restriction == 2
          target = $game_troop.random_target_enemy
        else
          index = @active_battler.current_action.target_index
          target = $game_troop.smooth_target_enemy(index)
        end
      end
      # Set array of targeted battlers
      @target_battlers = [target]
      # Apply normal attack results
      for target in @target_battlers
        target.attack_effect(@active_battler)
      end
      return
    end
    # If guard
    if @active_battler.current_action.basic == 1
      # Display "Guard" in help window
      @help_window.set_text($data_system.words.guard, 1)
      return
    end
    # If escape
    if @active_battler.is_a?(Game_Enemy) and
       @active_battler.current_action.basic == 2
      # Display "Escape" in help window
      @help_window.set_text("Uciekaj", 1)
      # Escape
      @active_battler.escape
      return
    end
    # If doing nothing
    if @active_battler.current_action.basic == 3
      # Clear battler being forced into action
      $game_temp.forcing_battler = nil
      # Shift to step 1
      @phase4_step = 1
      return
    end
  end
  #--------------------------------------------------------------------------
  # * Set Targeted Battler for Skill or Item
  #     scope : effect scope for skill or item
  #--------------------------------------------------------------------------
  def set_target_battlers(scope)
    # If battler performing action is enemy
    if @active_battler.is_a?(Game_Enemy)
      # Branch by effect scope
      case scope
      when 1  # single enemy
        index = @active_battler.current_action.target_index
        @target_battlers.push($game_party.smooth_target_actor(index))
      when 2  # all enemies
        for actor in $game_party.actors
          if actor.exist?
            @target_battlers.push(actor)
          end
        end
      when 3  # single ally
        index = @active_battler.current_action.target_index
        @target_battlers.push($game_troop.smooth_target_enemy(index))
      when 4  # all allies
        for enemy in $game_troop.enemies
          if enemy.exist?
            @target_battlers.push(enemy)
          end
        end
      when 5  # single ally (HP 0)
        index = @active_battler.current_action.target_index
        enemy = $game_troop.enemies[index]
        if enemy != nil and enemy.hp0?
          @target_battlers.push(enemy)
        end
      when 6  # all allies (HP 0)
        for enemy in $game_troop.enemies
          if enemy != nil and enemy.hp0?
            @target_battlers.push(enemy)
          end
        end
      when 7  # user
        @target_battlers.push(@active_battler)
      end
    end
    # If battler performing action is actor
    if @active_battler.is_a?(Game_Actor)
      # Branch by effect scope
      case scope
      when 1  # single enemy
        index = @active_battler.current_action.target_index
        @target_battlers.push($game_troop.smooth_target_enemy(index))
      when 2  # all enemies
        for enemy in $game_troop.enemies
          if enemy.exist?
            @target_battlers.push(enemy)
          end
        end
      when 3  # single ally
        index = @active_battler.current_action.target_index
        @target_battlers.push($game_party.smooth_target_actor(index))
      when 4  # all allies
        for actor in $game_party.actors
          if actor.exist?
            @target_battlers.push(actor)
          end
        end
      when 5  # single ally (HP 0)
        index = @active_battler.current_action.target_index
        actor = $game_party.actors[index]
        if actor != nil and actor.hp0?
          @target_battlers.push(actor)
        end
      when 6  # all allies (HP 0)
        for actor in $game_party.actors
          if actor != nil and actor.hp0?
            @target_battlers.push(actor)
          end
        end
      when 7  # user
        @target_battlers.push(@active_battler)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Make Skill Action Results
  #--------------------------------------------------------------------------
  def make_skill_action_result
    # Get skill
    @skill = $data_skills[@active_battler.current_action.skill_id]
    # If not a forcing action
    unless @active_battler.current_action.forcing
      # If unable to use due to SP running out
      unless @active_battler.skill_can_use?(@skill.id)
        # Clear battler being forced into action
        $game_temp.forcing_battler = nil
        # Shift to step 1
        @phase4_step = 1
        return
      end
    end
    # Use up SP
    @active_battler.sp -= @skill.sp_cost
    # Refresh status window
    @status_window.refresh
    # Show skill name on help window
    @help_window.set_text(@skill.name, 1)
    # Set animation ID
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    # Set command event ID
    @common_event_id = @skill.common_event_id
    # Set target battlers
    set_target_battlers(@skill.scope)
    # Apply skill effect
    for target in @target_battlers
      target.skill_effect(@active_battler, @skill)
    end
  end
  #--------------------------------------------------------------------------
  # * Make Item Action Results
  #--------------------------------------------------------------------------
  def make_item_action_result
    # Get item
    @item = $data_items[@active_battler.current_action.item_id]
    # If unable to use due to items running out
    unless $game_party.item_can_use?(@item.id)
      # Shift to step 1
      @phase4_step = 1
      return
    end
    # If consumable
    if @item.consumable
      # Decrease used item by 1
      $game_party.lose_item(@item.id, 1)
    end
    # Display item name on help window
    @help_window.set_text(@item.name, 1)
    # Set animation ID
    @animation1_id = @item.animation1_id
    @animation2_id = @item.animation2_id
    # Set common event ID
    @common_event_id = @item.common_event_id
    # Decide on target
    index = @active_battler.current_action.target_index
    target = $game_party.smooth_target_actor(index)
    # Set targeted battlers
    set_target_battlers(@item.scope)
    # Apply item effect
    for target in @target_battlers
      target.item_effect(@item)
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 3 : animation for action performer)
  #--------------------------------------------------------------------------
  def update_phase4_step3
    # Animation for action performer (if ID is 0, then white flash)
    if @animation1_id == 0
      @active_battler.white_flash = true
    else
      @active_battler.animation_id = @animation1_id
      @active_battler.animation_hit = true
    end
    # Shift to step 4
    @phase4_step = 4
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 4 : animation for target)
  #--------------------------------------------------------------------------
  def update_phase4_step4
    # Animation for target
    for target in @target_battlers
      target.animation_id = @animation2_id
      target.animation_hit = (target.damage != "Unik!")
    end
    # Animation has at least 8 frames, regardless of its length
    @wait_count = 8
    # Shift to step 5
    @phase4_step = 5
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 5 : damage display)
  #--------------------------------------------------------------------------
  def update_phase4_step5
    # Hide help window
    @help_window.visible = false
    # Refresh status window
    @status_window.refresh
    # Display damage
    for target in @target_battlers
      if target.damage != nil
        target.damage_pop = true
      end
    end
    # Shift to step 6
    @phase4_step = 6
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 6 : refresh)
  #--------------------------------------------------------------------------
  def update_phase4_step6
    # Clear battler being forced into action
    $game_temp.forcing_battler = nil
    # If common event ID is valid
    if @common_event_id > 0
      # Set up event
      common_event = $data_common_events[@common_event_id]
      $game_system.battle_interpreter.setup(common_event.list, 0)
    end
    # Shift to step 1
    @phase4_step = 1
  end
end

Nie jestem pewien czy w RM-ie z Twierdzy jest taki sam Scene_Battle 4, więc zapisz sobie wcześniej aktualny Scene_Battle 4 (np. w wordzie)

[ADI]

Spoiler proszę...

Na mojej X8 5 min przewijam tą strone od góry.na dół XD

No chyba że to właśnie przez mój telefon - to sorki



//wygaśnie

[WestGames]

ADI to chyba przez telefon XD
A co do skryptu - nadal wyświetla się "Run"

[ReetzO]

Krzyknij 'Hej Ayene!' to przybędzie świetna skrypterka(?) i może coś wymyśli. :3
Chociaż nie wiem, czy ona tak samo dobrze skryptuje(?) w XP jak w VX.
Warto spróbować ;)