____

Scripts RPG Maker XP

- Totalité

Nombre de scripts : 105
Derniers scripts :

Changer la taille de l'écran de votre jeu

Système Online - Net RMXP 2008

Combat ADB (comme Final Fantasy 12)

Combat amélioré.

Auteur : fukuyama

Fonction : Permet de mettre une interface du combat plus joli (voir le screen ci -dessous)

Image(s) : Image n°1

Ressource(s) : Aucune

Démo : Aucune

Remarque : Testé et fonctionnel

Nombre de scripts : 1

Installation : Copiez le code, ouvrez l'éditeur de script ( F11 ) et créez en un nouveau au dessus de 'Main'. Collez ce script :

Utilisation : Aucune

Code :

#============================================================================== 
# ¦ 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/~fukuyama/rgss/Battle_End_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‚ðXV 
@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

#============================================================================== 
# ¡ 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ƒhI—¹ 
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 # XV 
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ƒvEƒ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ƒ[ƒ^[‚Ì‚Ý‚ÌXV 
#-------------------------------------------------------------------------- 
# œ ƒ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, "Fuir"]) 
@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ƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV (ƒ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ƒŒ[ƒ€XV (ƒƒ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ƒhI—¹ 
return 
end 
# –¢s“®ƒoƒgƒ‰[”z—ñ‚Ìæ“ª‚©‚çŽæ“¾ 
@active_battler = @action_battlers[0] 
# ƒXƒe[ƒ^ƒXXV‚ðCP‚¾‚¯‚ÉŒÀ’èB 
@status_window.update_cp_only = true 
# ƒXƒe[ƒgXV‚ð‹ÖŽ~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ƒŒ[ƒ€XV (ƒƒ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ƒŒ[ƒ€XV (ƒƒ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ƒŒ[ƒ€XV (ƒƒ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[ƒ^ƒXEƒ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ƒ[ƒ^[‚Ì‚Ý‚ÌXV 
#-------------------------------------------------------------------------- 
# œ ƒ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ŒêuHPv‚Æ—pŒêuSPv‚Ì•`ŽÊ 
self.contents.font.size = 12 # —pŒêuHP/SPv‚Ì•Žš‚Ì‘å‚«‚³ 
self.contents.font.color = system_color # —pŒêuHP/SPv‚Ì•Žš‚Ì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ŽZB‘å‚«‚ß‚É’¼Š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

Informations

Page vue 1565623 fois | Auteur : Samarium