Pokémon Police

# Momo Camera Script
# Zoom battle effect
# Modificado por Soramaro para La Compañia Nodws
# 基本的に導入するだけで大丈夫です。
#
# 2005.5.18 バグ修正
# Arrow_Actor 修正
# self.enemy → self.actor
# アホなミスを犯してました。
#
# 2005.11.5 更新
# 設定項目を増やしました。
# いくつかの項目は、デフォルト(アクターがバトルフィールド上にいない)状態だと
# 変になるので、適切設定してください。
# (デフォ状態でtrueにするとマズイものには★をつけてます)

module MoMo_Camera
 # カメラの移動にかけるフレーム数の初期値
 MOVE_SPEED_INI = 8
 # カメラのズームにかけるフレーム数の初期値
 ZOOM_SPEED_INI = 8
 # バトルバック引き伸ばし率追加値(0.0で引き伸ばし無し)
 BATTLEBACK_ZOOM = 1.0
 
 # アクターもカメラの影響を受けるようにする ★
 # (★のついている項目を true にする場合などはこちらも true にして下さい)
 CAMERA_UPDATE_ACTOR = false
 
 # エネミー通常攻撃時、行動者を注視する
 ACTIVE_LOOK_ENEMY_NOMAL_ATTACK = true
 # エネミー防御時、行動者を注視する
 ACTIVE_LOOK_ENEMY_GUARD = true
 # エネミー逃走時、行動者を注視する
 ACTIVE_LOOK_ENEMY_ESCAPE = true
 # エネミースキル使用時、行動者を注視する
 ACTIVE_LOOK_ENEMY_SKILL = true
 # エネミー選択時、選択エネミーを注視する
 ACTIVE_LOOK_ENEMY_SELECT = true
 
 # エネミー通常攻撃時、対象者を注視する(対象がアクターの時) ★
 TARGET_LOOK_ENEMY_NOMAL_ATTACK_TR_ACTOR = false
 # エネミー通常攻撃時、対象者を注視する(対象がエネミーの時)
 TARGET_LOOK_ENEMY_NOMAL_ATTACK_TR_ENEMY = true
 # エネミースキル使用時、対象者を注視する(対象がアクターの時) ★
 TARGET_LOOK_ENEMY_SKILL_TR_ACTOR = false
 # エネミースキル使用時、対象者を注視する(対象がエネミーの時)
 TARGET_LOOK_ENEMY_SKILL_TR_ENEMY = true
 
 # エネミークリティカル発生時は問答無用で対象を注視する(対象がアクターの時) ★
 CLITICAL_LOOK_ENEMY_TR_ACTOR = false
 # エネミークリティカル発生時は問答無用で対象を注視する(対象がエネミーの時)
 CLITICAL_LOOK_ENEMY_TR_ENEMY = true
 # エネミークリティカル発生時のズーム倍率(ズームしたくない時は0.0を設定)
 CRITICAL_ZOOM_ENEMY = 0.3
 
 # アクター通常攻撃時、行動者を注視する ★
 ACTIVE_LOOK_ACTOR_NOMAL_ATTACK = false
 # アクター防御時、行動者を注視する ★
 ACTIVE_LOOK_ACTOR_GUARD = false
 # アクター逃走時、行動者を注視する ★
 ACTIVE_LOOK_ACTOR_ESCAPE = false
 # アクタースキル使用時、行動者を注視する ★
 ACTIVE_LOOK_ACTOR_SKILL = false
 # アクターアイテム使用時、行動者を注視する ★
 ACTIVE_LOOK_ACTOR_ITEM = false
 # アクター選択時、選択アクターを注視する ★
 ACTIVE_LOOK_ACTOR_SELECT = false
 
 # アクター通常攻撃時、対象者を注視する(対象がアクターの時) ★
 TARGET_LOOK_ACTOR_NOMAL_ATTACK_TR_ACTOR = false
 # アクター通常攻撃時、対象者を注視する(対象がエネミーの時)
 TARGET_LOOK_ACTOR_NOMAL_ATTACK_TR_ENEMY = true
 # アクタースキル使用時、対象者を注視する(対象がアクターの時) ★
 TARGET_LOOK_ACTOR_SKILL_TR_ACTOR = false
 # アクタースキル使用時、対象者を注視する(対象がエネミーの時)
 TARGET_LOOK_ACTOR_SKILL_TR_ENEMY = true
 # アクターアイテム使用時、対象者を注視する(対象がアクターの時) ★
 TARGET_LOOK_ACTOR_ITEM_TR_ACTOR = false
 # アクターアイテム使用時、対象者を注視する(対象がエネミーの時)
 TARGET_LOOK_ACTOR_ITEM_TR_ENEMY = true
 
 # アクタークリティカル発生時は問答無用で対象を注視する(対象がアクターの時) ★
 CLITICAL_LOOK_ACTOR_TR_ACTOR = true
 # アクタークリティカル発生時は問答無用で対象を注視する(対象がエネミーの時)
 CLITICAL_LOOK_ACTOR_TR_ENEMY = true
 # アクタークリティカル発生時のズーム倍率(ズームしたくない時は0.0を設定)
 CRITICAL_ZOOM_ACTOR = 0.3
 
 # エネミースリップダメージ時に注視する
 LOOK_ENEMY_SLIP_DAMAGE = true
 
 # アクタースリップダメージ時に注視する ★
 LOOK_ACTOR_SLIP_DAMAGE = false
 
 # コマンド入力時に、アクターを注視 ★
 LOOK_ACTOR_COMMAND_INPUT = false
 
 # 行動終了毎にカメラをセンタリング
 EACH_ACTION_CENTERING = true
 
 # 全体攻撃時のズーム率
 ALL_ATTACK_ZOOM = 0.6
end

class Battle_Camera
 attr_accessor :x
 attr_accessor :y
 attr_accessor :zoom
 attr_accessor :new_x
 attr_accessor :new_y
 attr_accessor :new_zoom
 def initialize
   @x = 320
   @y = 160
   @zoom = 1.0
   @new_x = @x
   @new_y = @y
   @dis_x = 0
   @dis_y = 0
   @dis_zoom = 0.0
   @new_zoom = @zoom
   @move_speed = MoMo_Camera::MOVE_SPEED_INI
   @zoom_speed = MoMo_Camera::ZOOM_SPEED_INI
 end
 # 新しい移動先設定
 def new_x=(newx)
   @new_x = newx
   @dis_x = (@x - @new_x).abs
 end
 def new_y=(newy)
   @new_y = newy
   @dis_y = (@y - @new_y).abs
 end
 def new_zoom=(newz)
   @new_zoom = newz
   @dis_zoom = (@zoom - @new_zoom).abs
 end
 # カメラセット
 def set(x, y, zoom=nil, speed=nil)
   unless speed.nil?
     @move_speed = speed
     @zoom_speed = speed
   end
   self.new_x = x
   self.new_y = y
   self.new_zoom = zoom unless zoom.nil?
 end
 # カメラを真ん中に
 def center(zoom=1.0)
   self.new_x = 320
   self.new_y = 160
   self.new_zoom = zoom
 end
 # バトラー注視
 def battler_look(battler)
   hei = get_battler_height(battler)
   zoom = [160.0 / hei, 0.8].max
   self.new_zoom = zoom
   self.new_x = battler.screen_x
   self.new_y = (battler.screen_y - hei / 2 * [[@new_zoom, 1.0].max, 1.5].min).truncate
 end
 # バトラーの計算色々
 def battler_x_plus(battler)
   dis = battler.screen_x - @x
   val = dis * (@zoom - 1.0)
   return val
 end
 def pos_battler_x(battler)
   return battler.screen_x - (@x - 320)
 end
 def battler_x(battler)
   return pos_battler_x(battler) + battler_x_plus(battler)
 end
 def battler_y_plus(battler)
   dis = battler.screen_y - @y
   val = dis * (@zoom - 1.0)
   return val
 end
 def pos_battler_y(battler)
   return battler.screen_y - (@y - 160)
 end
 def battler_y(battler)
   return pos_battler_y(battler) + battler_y_plus(battler)
 end
 # 更新
 def update
   if @x != @new_x
     if @new_x - @x > 0
       @x = [@x + move_speed_x, @new_x].min
     else
       @x = [@x - move_speed_x, @new_x].max
     end
   end
   if @y != @new_y
     if @new_y - @y > 0
       @y = [@y + move_speed_y, @new_y].min
     else
       @y = [@y - move_speed_y, @new_y].max
     end
   end
   if @zoom != @new_zoom
     if @new_zoom - @zoom > 0
       @zoom = [@zoom + zoom_speed, @new_zoom].min
     else
       @zoom = [@zoom - zoom_speed, @new_zoom].max
     end
   end
 end
 # 移動距離計算
 def move_speed_x
   return [(@dis_x / @move_speed).to_i, 1].max
 end
 def move_speed_y
   return [(@dis_y / @move_speed).to_i, 1].max
 end
 # ズーム倍率計算
 def zoom_speed
   return [(@dis_zoom / @zoom_speed), 0.01].max
 end
 def get_battler_height(battler)
   bammy = get_battler_bmp(battler)
   return bammy.height
 end
 def get_battler_bmp(battler)
   return RPG::Cache.battler(battler.battler_name, battler.battler_hue)
 end
 def move?
   return (@x != @new_x or @y != @new_y or @zoom != @new_zoom)
 end
end

#==============================================================================
# ■ Spriteset_Battle
#------------------------------------------------------------------------------
# 　バトル画面のスプライトをまとめたクラスです。このクラスは Scene_Battle クラ
# スの内部で使用されます。
#==============================================================================

class Spriteset_Battle
 attr_accessor :battle_camera
 #--------------------------------------------------------------------------
 # ● オブジェクト初期化
 #--------------------------------------------------------------------------
 alias spriteset_battle_battle_camera_initialize initialize
 def initialize
   @battle_camera = Battle_Camera.new
   spriteset_battle_battle_camera_initialize
   @battleback_sprite.ox = @viewport1.rect.width / 2
   @battleback_sprite.oy = @viewport1.rect.height / 2
   camera_battleback_scroll
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新
 #--------------------------------------------------------------------------
 alias spriteset_battle_battle_camera_update update
 def update
   spriteset_battle_battle_camera_update
   camera_update
 end
 # 更新するバトラーの指定
 def camera_update_battlers
   if MoMo_Camera::CAMERA_UPDATE_ACTOR
     return @enemy_sprites + @actor_sprites
   else
     return @enemy_sprites
   end
 end
 # カメラ更新
 def camera_update
   @battle_camera.update
   camera_battleback_scroll
   camera_battleback_zoom
   camera_battler_update
 end
 # カメラ更新:バトルバックスクロール
 def camera_battleback_scroll
   # バトルバックの計算色々
   view_width = @viewport1.rect.width / 2
   view_height = @viewport1.rect.height / 2
   @battleback_sprite.x = view_width + (view_width - @battle_camera.x) * @battle_camera.zoom
   @battleback_sprite.y = view_height + (view_height - @battle_camera.y) * @battle_camera.zoom
 end
 # カメラ更新:バトルバックズーム
 def camera_battleback_zoom
   @battleback_sprite.zoom_x = @battle_camera.zoom + MoMo_Camera::BATTLEBACK_ZOOM
   @battleback_sprite.zoom_y = @battle_camera.zoom + MoMo_Camera::BATTLEBACK_ZOOM
 end
 # カメラ更新:バトラースプライト更新
 def camera_battler_update
   for sprite in camera_update_battlers
     battler_sprite_zoom(sprite)
     battler_sprite_scroll(sprite)
   end
 end
 # カメラ更新:バトラースプライト更新:バトラースプライトスクロール
 def battler_sprite_scroll(sprite)
   if !sprite.nil? and !sprite.battler.nil?
     sprite.x = @battle_camera.battler_x(sprite.battler)
     sprite.y = @battle_camera.battler_y(sprite.battler)
   end
 end
 # カメラ更新:バトラースプライト更新:バトラースプライトズーム
 def battler_sprite_zoom(sprite)
   unless sprite.nil?
     sprite.zoom_x = @battle_camera.zoom
     sprite.zoom_y = @battle_camera.zoom
   end
 end
end

class Arrow_Actor < Arrow_Base
 attr_accessor :camera
 #--------------------------------------------------------------------------
 # ● フレーム更新
 #--------------------------------------------------------------------------
 alias arrow_actor_battle_camera_update update
 def update
   arrow_actor_battle_camera_update
   # スプライトの座標を再設定
   if self.actor != nil and @camera != nil
     self.x = @camera.battler_x(self.actor)
     self.y = @camera.battler_y(self.actor)
   end
 end
end

class Arrow_Enemy < Arrow_Base
 attr_accessor :camera
 #--------------------------------------------------------------------------
 # ● フレーム更新
 #--------------------------------------------------------------------------
 alias arrow_enemy_battle_camera_update update
 def update
   arrow_enemy_battle_camera_update
   # スプライトの座標を再設定
   if self.enemy != nil and @camera != nil
     self.x = @camera.battler_x(self.enemy)
     self.y = @camera.battler_y(self.enemy)
   end
 end
end

class Scene_Battle
 def camera
   return @spriteset.battle_camera
 end
 
 # 行動側アニメーション中のカメラワーク判定
 def camera_action_judge_active
   if @active_battler.is_a?(Game_Enemy)
     case @active_battler.current_action.kind
     when 0
       camera_action_judge_active_basic_enemy
     when 1
       camera_action_judge_active_skill_enemy
     when 2
       camera_action_judge_active_item_enemy
     end
   else
     case @active_battler.current_action.kind
     when 0
       camera_action_judge_active_basic_actor
     when 1
       camera_action_judge_active_skill_actor
     when 2
       camera_action_judge_active_item_actor
     end
   end
 end
 # 行動側アニメ中のカメラワーク(エネミー):基本
 def camera_action_judge_active_basic_enemy
   case @active_battler.current_action.basic
   when 0
     camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ENEMY_NOMAL_ATTACK
   when 1
     camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ENEMY_GUARD
   when 2
     camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ENEMY_ESCAPE
   end
 end
 # 行動側アニメ中のカメラワーク(エネミー):スキル
 def camera_action_judge_active_skill_enemy
   camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ENEMY_SKILL
 end
 # 行動側アニメ中のカメラワーク(エネミー):アイテム(一応実装)
 def camera_action_judge_active_item_enemy
   camera.battler_look(@active_battler)
 end
 # 行動側アニメ中のカメラワーク(アクター):基本
 def camera_action_judge_active_basic_actor
   case @active_battler.current_action.basic
   when 0
     camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ACTOR_NOMAL_ATTACK
   when 1
     camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ACTOR_GUARD
   when 2
     camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ACTOR_ESCAPE
   end
 end
 # 行動側アニメ中のカメラワーク(アクター):スキル
 def camera_action_judge_active_skill_actor
   camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ACTOR_SKILL
 end
 # 行動側アニメ中のカメラワーク(アクター):アイテム
 def camera_action_judge_active_item_actor
   camera.battler_look(@active_battler) if MoMo_Camera::ACTIVE_LOOK_ACTOR_ITEM
 end
 
 # 対象側アニメーション中のカメラワーク判定
 def camera_action_judge_target
   if @active_battler.is_a?(Game_Enemy)
     case @active_battler.current_action.kind
     when 0
       camera_action_judge_target_basic_enemy
     when 1
       camera_action_judge_target_skill_enemy
     when 2
       camera_action_judge_target_item_enemy
     end
   else
     case @active_battler.current_action.kind
     when 0
       camera_action_judge_target_basic_actor
     when 1
       camera_action_judge_target_skill_actor
     when 2
       camera_action_judge_target_item_actor
     end
   end
 end
 
 # 対象側アニメ中のカメラワーク(エネミー):基本
 def camera_action_judge_target_basic_enemy
   case @active_battler.current_action.basic
   when 0
     camera_action_judge_target_basic_enemy_attack
   when 1
     camera_action_judge_target_basic_enemy_guard
   when 2
     camera_action_judge_target_basic_enemy_escape
   when 3
     camera_action_judge_target_basic_enemy_none
   end
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:攻撃
 def camera_action_judge_target_basic_enemy_attack
   if @target_battlers.size > 1
     camera.center(MoMo_Camera::ALL_ATTACK_ZOOM)
   else
     if @target_battlers[0].is_a?(Game_Actor)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ENEMY_NOMAL_ATTACK_TR_ACTOR
       if @target_battlers[0].critical
         if MoMo_Camera::CLITICAL_LOOK_ENEMY_TR_ACTOR
           camera.battler_look(@target_battlers[0])
         end
         camera.new_zoom = camera.new_zoom + MoMo_Camera::CRITICAL_ZOOM_ENEMY
       end
     elsif @target_battlers[0].is_a?(Game_Enemy)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ENEMY_NOMAL_ATTACK_TR_ENEMY
       if @target_battlers[0].critical
         if MoMo_Camera::CLITICAL_LOOK_ENEMY_TR_ENEMY
           camera.battler_look(@target_battlers[0])
         end
         camera.new_zoom = camera.new_zoom + MoMo_Camera::CRITICAL_ZOOM_ENEMY
       end
     else
       camera.center
     end
   end
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:防御
 def camera_action_judge_target_basic_enemy_guard
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:逃走
 def camera_action_judge_target_basic_enemy_escape
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:なにもしない
 def camera_action_judge_target_basic_enemy_none
 end
 
 # 対象側アニメ中のカメラワーク(エネミー):スキル
 def camera_action_judge_target_skill_enemy
   if @target_battlers.size > 1
     camera.center(MoMo_Camera::ALL_ATTACK_ZOOM)
   elsif @target_battlers.size == 1
     if @target_battlers[0].is_a?(Game_Actor)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ENEMY_SKILL_TR_ACTOR
     elsif @target_battlers[0].is_a?(Game_Enemy)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ENEMY_SKILL_TR_ENEMY
     end
   else
     camera.center
   end
 end
 # 対象側アニメ中のカメラワーク(エネミー):アイテム(一応実装)
 def camera_action_judge_target_item_enemy
 end
 
 # 対象側アニメ中のカメラワーク(アクター):基本
 def camera_action_judge_target_basic_actor
   case @active_battler.current_action.basic
   when 0
     camera_action_judge_target_basic_actor_attack
   when 1
     camera_action_judge_target_basic_actor_guard
   when 2
     camera_action_judge_target_basic_actor_escape
   when 3
     camera_action_judge_target_basic_actor_none
   end
 end
 # 対象側アニメ中のカメラワーク(アクター):基本:攻撃
 def camera_action_judge_target_basic_actor_attack
   if @target_battlers.size > 1
     camera.center(MoMo_Camera::ALL_ATTACK_ZOOM)
   else
     if @target_battlers[0].is_a?(Game_Actor)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ACTOR_NOMAL_ATTACK_TR_ACTOR
       if @target_battlers[0].critical
         if MoMo_Camera::CLITICAL_LOOK_ACTOR_TR_ACTOR
           camera.battler_look(@target_battlers[0])
         end
         camera.new_zoom = camera.new_zoom + MoMo_Camera::CRITICAL_ZOOM_ACTOR
       end
     elsif @target_battlers[0].is_a?(Game_Enemy)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ACTOR_NOMAL_ATTACK_TR_ENEMY
       if @target_battlers[0].critical
         if MoMo_Camera::CLITICAL_LOOK_ACTOR_TR_ENEMY
           camera.battler_look(@target_battlers[0])
         end
         camera.new_zoom = camera.new_zoom + MoMo_Camera::CRITICAL_ZOOM_ACTOR
       end
     else
       camera.center
     end
   end
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:防御
 def camera_action_judge_target_basic_actor_guard
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:逃走
 def camera_action_judge_target_basic_actor_escape
 end
 # 対象側アニメ中のカメラワーク(エネミー):基本:なにもしない
 def camera_action_judge_target_basic_actor_none
 end
 # 対象側アニメ中のカメラワーク(アクター):スキル
 def camera_action_judge_target_skill_actor
   if @target_battlers.size > 1
     camera.center(MoMo_Camera::ALL_ATTACK_ZOOM)
   elsif @target_battlers.size == 1
     if @target_battlers[0].is_a?(Game_Actor)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ACTOR_SKILL_TR_ACTOR
     elsif @target_battlers[0].is_a?(Game_Enemy)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ACTOR_SKILL_TR_ENEMY
     end
   else
     camera.center
   end
 end
 # 対象側アニメ中のカメラワーク(アクター):アイテム
 def camera_action_judge_target_item_actor
   if @target_battlers.size > 1
     camera.center(MoMo_Camera::ALL_ATTACK_ZOOM)
   elsif @target_battlers.size == 1
     if @target_battlers[0].is_a?(Game_Actor)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ACTOR_ITEM_TR_ACTOR
     elsif @target_battlers[0].is_a?(Game_Enemy)
       camera.battler_look(@target_battlers[0]) if MoMo_Camera::TARGET_LOOK_ACTOR_ITEM_TR_ENEMY
     else
     end
   else
     camera.center
   end
 end
 #--------------------------------------------------------------------------
 # ● パーティコマンドフェーズ開始
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_start_phase2 start_phase2
 def start_phase2
   camera.center
   scene_battle_battle_camera_start_phase2
 end
 #--------------------------------------------------------------------------
 # ● アフターバトルフェーズ開始
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_start_phase5 start_phase5
 def start_phase5
   camera.center
   scene_battle_battle_camera_start_phase5
 end
 #--------------------------------------------------------------------------
 # ● 次のアクターのコマンド入力へ
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_phase3_next_actor phase3_next_actor
 def phase3_next_actor
   scene_battle_battle_camera_phase3_next_actor
   if @active_battler != nil and MoMo_Camera::LOOK_ACTOR_COMMAND_INPUT
     camera.battler_look(@active_battler)
   end
 end
 #--------------------------------------------------------------------------
 # ● 前のアクターのコマンド入力へ
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_phase3_prior_actor phase3_prior_actor
 def phase3_prior_actor
   scene_battle_battle_camera_phase3_prior_actor
   if @active_battler != nil and MoMo_Camera::LOOK_ACTOR_COMMAND_INPUT
     camera.battler_look(@active_battler)
   end
 end
 #--------------------------------------------------------------------------
 # ● アクター選択開始
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_start_actor_select start_actor_select
 def start_actor_select
   scene_battle_battle_camera_start_actor_select
   if MoMo_Camera::ACTIVE_LOOK_ACTOR_SELECT
     @last_arrow_index = nil
     @actor_arrow.camera = camera
   elsif MoMo_Camera::LOOK_ACTOR_COMMAND_INPUT
     camera.center
   end
 end
 #--------------------------------------------------------------------------
 # ● アクター選択終了
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_end_actor_select end_actor_select
 def end_actor_select
   scene_battle_battle_camera_end_actor_select
   if MoMo_Camera::LOOK_ACTOR_COMMAND_INPUT
     camera.battler_look(@active_battler)
   else
     camera.center
   end
 end
 #--------------------------------------------------------------------------
 # ● エネミー選択開始
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_start_enemy_select start_enemy_select
 def start_enemy_select
   scene_battle_battle_camera_start_enemy_select
   if MoMo_Camera::ACTIVE_LOOK_ENEMY_SELECT
     @last_arrow_index = nil
     @enemy_arrow.camera = camera
   elsif MoMo_Camera::LOOK_ACTOR_COMMAND_INPUT
     camera.center
   end
 end
 #--------------------------------------------------------------------------
 # ● エネミー選択終了
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_end_enemy_select end_enemy_select
 def end_enemy_select
   scene_battle_battle_camera_end_enemy_select
   if MoMo_Camera::LOOK_ACTOR_COMMAND_INPUT
     camera.battler_look(@active_battler)
   else
     camera.center
   end
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新 (アクターコマンドフェーズ : アクター選択)
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_update_phase3_actor_select update_phase3_actor_select
 def update_phase3_actor_select
   scene_battle_battle_camera_update_phase3_actor_select
   if MoMo_Camera::ACTIVE_LOOK_ACTOR_SELECT
     if @actor_arrow != nil and (@last_arrow_index != @actor_arrow.index)
       @last_arrow_index = @actor_arrow.index
       camera.battler_look(@actor_arrow.actor)
     end
   end
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新 (アクターコマンドフェーズ : エネミー選択)
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_update_phase3_enemy_select update_phase3_enemy_select
 def update_phase3_enemy_select
   scene_battle_battle_camera_update_phase3_enemy_select
   if MoMo_Camera::ACTIVE_LOOK_ENEMY_SELECT
     if @enemy_arrow != nil and (@last_arrow_index != @enemy_arrow.index)
       @last_arrow_index = @enemy_arrow.index
       camera.battler_look(@enemy_arrow.enemy)
     end
   end
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新 (メインフェーズ ステップ 1 : アクション準備)
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_update_phase4_step1 update_phase4_step1
 def update_phase4_step1
   unless @camera_move
     if $game_temp.forcing_battler == nil and @action_battlers.size != 0 and
        @action_battlers[0].slip_damage?
       camera_action_judge_phase4_step1
     end
     @camera_move = true
   end
   return if camera.move?
   @camera_move = false
   scene_battle_battle_camera_update_phase4_step1
 end
 def camera_action_judge_phase4_step1
   if @action_battlers[0].is_a?(Game_Enemy)
     camera.battler_look(@action_battlers[0]) if MoMo_Camera::LOOK_ENEMY_SLIP_DAMAGE
   elsif @action_battlers[0].is_a?(Game_Actor)
     camera.battler_look(@action_battlers[0]) if MoMo_Camera::LOOK_ACTOR_SLIP_DAMAGE
   end
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新 (メインフェーズ ステップ 3 : 行動側アニメーション)
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_update_phase4_step3 update_phase4_step3
 def update_phase4_step3
   unless @camera_move
     camera_action_judge_active
     @camera_move = true
   end
   return if camera.move?
   @camera_move = false
   scene_battle_battle_camera_update_phase4_step3
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新 (メインフェーズ ステップ 4 : 対象側アニメーション)
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_update_phase4_step4 update_phase4_step4
 def update_phase4_step4
   unless @camera_move
     camera_action_judge_target
     @camera_move = true
   end
   return if camera.move?
   @camera_move = false
   scene_battle_battle_camera_update_phase4_step4
 end
 #--------------------------------------------------------------------------
 # ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
 #--------------------------------------------------------------------------
 alias scene_battle_battle_camera_update_phase4_step6 update_phase4_step6
 def update_phase4_step6
   scene_battle_battle_camera_update_phase4_step6
   camera.center if MoMo_Camera::EACH_ACTION_CENTERING
 end
end

#===================================
# Creado por Corbaque
#---------------------------------------------------------------
# El 19/08/2006
#---------------------------------------------------------------
# Modification de l'affichage des dégats
#---------------------------------------------------------------
# Version 1.0
#===================================
module RPG
# ces trois constantes sont modifiables
POLICE_DES_LETTRES = "Tahoma"
COULEUR_DES_LETTRES = Color.new(189, 244, 0)
COULEUR_DU_CONTOUR = Color.new(236, 117, 9)
# Modification de la classe sprite
class Sprite < ::Sprite
@@_animations = []
@@_reference_count = {}
def initialize(viewport = nil)
super(viewport)
@_whiten_duration = 0
@_appear_duration = 0
@_escape_duration = 0
@_collapse_duration = 0
@_damage_duration = 0
@_animation_duration = 0
@_blink = false
end
def dispose
dispose_damage
dispose_animation
dispose_loop_animation
super
end
def whiten
self.blend_type = 0
self.color.set(255, 255, 255, 128)
self.opacity = 255
@_whiten_duration = 16
@_appear_duration = 0
@_escape_duration = 0
@_collapse_duration = 0
end
def appear
self.blend_type = 0
self.color.set(0, 0, 0, 0)
self.opacity = 0
@_appear_duration = 16
@_whiten_duration = 0
@_escape_duration = 0
@_collapse_duration = 0
end
def escape
self.blend_type = 0
self.color.set(0, 0, 0, 0)
self.opacity = 255
@_escape_duration = 32
@_whiten_duration = 0
@_appear_duration = 0
@_collapse_duration = 0
end
def collapse
self.blend_type = 1
self.color.set(255, 64, 64, 255)
self.opacity = 255
@_collapse_duration = 48
@_whiten_duration = 0
@_appear_duration = 0
@_escape_duration = 0
end
#-----------------------------------------------------------
# Redéfinition de la methode damage
#-----------------------------------------------------------
def damage(value, critical)
# Suprimme le dernière affichage de
# dommage si ce n'est pas fait
dispose_damage
# Transforme la valeur en chaine de caractère
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
# définition du bitmap
bitmap = Bitmap.new(160, 48)
bitmap.font.name = POLICE_DES_LETTRES
bitmap.font.size = 28
bitmap.font.color = Color.new(0, 232, 232)
bitmap.draw_text(-1, 12, 160, 36, damage_string, 1)
bitmap.draw_text(0, 13, 160, 36, damage_string, 1)
bitmap.draw_text(1, 13, 160, 36, damage_string, 1)
bitmap.draw_text(1, 12, 160, 36, damage_string, 1)
if value.is_a?(Numeric) and value < 0
bitmap.font.color.set(255, 255, 255)
else
bitmap.font.color = Color.new(244, 0, 6)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical
bitmap.font.size = 28
bitmap.font.color = Color.new(255, 210, 177)
bitmap.draw_text(-1, -1, 160, 20, "Golpe CrÃ*tico", 1)
bitmap.draw_text(+1, -1, 160, 20, "Golpe CrÃ*tico", 1)
bitmap.draw_text(-1, +1, 160, 20, "Golpe CrÃ*tico", 1)
bitmap.draw_text(+1, +1, 160, 20, "Golpe CrÃ*tico", 1)
bitmap.font.color = Color.new(244, 0, 6)
bitmap.draw_text(0, 0, 160, 20, "Golpe CrÃ*tico", 1)
end
# Définition du sprite
@_damage_sprite = ::Sprite.new(self.viewport)
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80
@_damage_sprite.oy = 20
@_damage_sprite.x = self.x
@_damage_sprite.y = self.y - self.oy / 2
@_damage_sprite.z = 3000
@_damage_sprite.zoom_x = 0
@_damage_sprite.zoom_y = 0
@_damage_duration = 40
end
def animation(animation, hit)
dispose_animation
@_animation = animation
return if @_animation == nil
@_animation_hit = hit
@_animation_duration = @_animation.frame_max
animation_name = @_animation.animation_name
animation_hue = @_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_animation_sprites = []
if @_animation.position != 3 or not @@_animations.include?(animation)
for i in 0..15
sprite = ::Sprite.new(self.viewport)
sprite.bitmap = bitmap
sprite.visible = false
@_animation_sprites.push(sprite)
end
unless @@_animations.include?(animation)
@@_animations.push(animation)
end
end
update_animation
end
def loop_animation(animation)
return if animation == @_loop_animation
dispose_loop_animation
@_loop_animation = animation
return if @_loop_animation == nil
@_loop_animation_index = 0
animation_name = @_loop_animation.animation_name
animation_hue = @_loop_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_loop_animation_sprites = []
for i in 0..15
sprite = ::Sprite.new(self.viewport)
sprite.bitmap = bitmap
sprite.visible = false
@_loop_animation_sprites.push(sprite)
end
update_loop_animation
end
def dispose_damage
if @_damage_sprite != nil
@_damage_sprite.bitmap.dispose
@_damage_sprite.dispose
@_damage_sprite = nil
@_damage_duration = 0
end
end
def dispose_animation
if @_animation_sprites != nil
sprite = @_animation_sprites[0]
if sprite != nil
@@_reference_count[sprite.bitmap] -= 1
if @@_reference_count[sprite.bitmap] == 0
sprite.bitmap.dispose
end
end
for sprite in @_animation_sprites
sprite.dispose
end
@_animation_sprites = nil
@_animation = nil
end
end
def dispose_loop_animation
if @_loop_animation_sprites != nil
sprite = @_loop_animation_sprites[0]
if sprite != nil
@@_reference_count[sprite.bitmap] -= 1
if @@_reference_count[sprite.bitmap] == 0
sprite.bitmap.dispose
end
end
for sprite in @_loop_animation_sprites
sprite.dispose
end
@_loop_animation_sprites = nil
@_loop_animation = nil
end
end
def blink_on
unless @_blink
@_blink = true
@_blink_count = 0
end
end
def blink_off
if @_blink
@_blink = false
self.color.set(0, 0, 0, 0)
end
end
def blink?
@_blink
end
def effect?
@_whiten_duration > 0 or
@_appear_duration > 0 or
@_escape_duration > 0 or
@_collapse_duration > 0 or
@_damage_duration > 0 or
@_animation_duration > 0
end
#-----------------------------------------------------------
# Redéfinition de la methode update
#-----------------------------------------------------------
def update
# Appel la class superieur (::Sprite)
super
#################################
# Mise à jour des autres éléments #
#################################
if @_whiten_duration > 0
@_whiten_duration -= 1
self.color.alpha = 128 - (16 - @_whiten_duration) * 10
end
if @_appear_duration > 0
@_appear_duration -= 1
self.opacity = (16 - @_appear_duration) * 16
end
if @_escape_duration > 0
@_escape_duration -= 1
self.opacity = 256 - (32 - @_escape_duration) * 10
end
if @_collapse_duration > 0
@_collapse_duration -= 1
self.opacity = 256 - (48 - @_collapse_duration) * 6
end
#################################
# Mouvement du sprite
if @_damage_duration > 0
@_damage_duration -= 1
case @_damage_duration
when 28..39
# Modification de la position du sprite
@_damage_sprite.x += 30 * Math.cos(@_damage_duration * Math::PI / 5)
@_damage_sprite.y += 15 * Math.sin(@_damage_duration * Math::PI / 5)
@_damage_sprite.zoom_x += 0.1
@_damage_sprite.zoom_y += 0.1
end
# fondu d'opacitée
@_damage_sprite.opacity = 256 - (12 - @_damage_duration) * 32
# supprime le sprite si l'effet est terminé
if @_damage_duration == 0
dispose_damage
end
end
#################################
# Mise à jour des autres éléments #
#################################
if @_animation != nil and (Graphics.frame_count % 2 == 0)
@_animation_duration -= 1
update_animation
end
if @_loop_animation != nil and (Graphics.frame_count % 2 == 0)
update_loop_animation
@_loop_animation_index += 1
@_loop_animation_index %= @_loop_animation.frame_max
end
if @_blink
@_blink_count = (@_blink_count + 1) % 32
if @_blink_count < 16
alpha = (16 - @_blink_count) * 6
else
alpha = (@_blink_count - 16) * 6
end
self.color.set(255, 255, 255, alpha)
end
@@_animations.clear
#################################
end
def update_animation
if @_animation_duration > 0
frame_index = @_animation.frame_max - @_animation_duration
cell_data = @_animation.frames[frame_index].cell_data
position = @_animation.position
animation_set_sprites(@_animation_sprites, cell_data, position)
for timing in @_animation.timings
if timing.frame == frame_index
animation_process_timing(timing, @_animation_hit)
end
end
else
dispose_animation
end
end
def update_loop_animation
frame_index = @_loop_animation_index
cell_data = @_loop_animation.frames[frame_index].cell_data
position = @_loop_animation.position
animation_set_sprites(@_loop_animation_sprites, cell_data, position)
for timing in @_loop_animation.timings
if timing.frame == frame_index
animation_process_timing(timing, true)
end
end
end
def animation_set_sprites(sprites, cell_data, position)
for i in 0..15
sprite = sprites[i]
pattern = cell_data[i, 0]
if sprite == nil or pattern == nil or pattern == -1
sprite.visible = false if sprite != nil
next
end
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
if position == 3
if self.viewport != nil
sprite.x = self.viewport.rect.width / 2
sprite.y = self.viewport.rect.height - 160
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x - self.ox + self.src_rect.width / 2
sprite.y = self.y - self.oy + self.src_rect.height / 2
sprite.y -= self.src_rect.height / 4 if position == 0
sprite.y += self.src_rect.height / 4 if position == 2
end
sprite.x += cell_data[i, 1]
sprite.y += cell_data[i, 2]
sprite.z = 2000
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
sprite.blend_type = cell_data[i, 7]
end
end
def animation_process_timing(timing, hit)
if (timing.condition == 0) or
(timing.condition == 1 and hit == true) or
(timing.condition == 2 and hit == false)
if timing.se.name != ""
se = timing.se
Audio.se_play("Audio/SE/" + se.name, se.volume, se.pitch)
end
case timing.flash_scope
when 1
self.flash(timing.flash_color, timing.flash_duration * 2)
when 2
if self.viewport != nil
self.viewport.flash(timing.flash_color, timing.flash_duration * 2)
end
when 3
self.flash(nil, timing.flash_duration * 2)
end
end
end
def x=(x)
sx = x - self.x
if sx != 0
if @_animation_sprites != nil
for i in 0..15
@_animation_sprites[i].x += sx
end
end
if @_loop_animation_sprites != nil
for i in 0..15
@_loop_animation_sprites[i].x += sx
end
end
end
super
end
def y=(y)
sy = y - self.y
if sy != 0
if @_animation_sprites != nil
for i in 0..15
@_animation_sprites[i].y += sy
end
end
if @_loop_animation_sprites != nil
for i in 0..15
@_loop_animation_sprites[i].y += sy
end
end
end
super
end
end
end

#==============================================================================
# 本脚本来自www.66RPG.com，使用和转载请保留此信息
#==============================================================================
# ■ エネミーHP&SP(ver 0.98)

# □ カスタマイズポイント
#==============================================================================
module PLAN_HPSP_DRAW
FONT_NAME         = ["Arial"]    # フォント
FONT_SIZE         =  18                            # フォントサイズ
FONT_BOLD         = true                              # 太字
FONT_ITALIC       = true                              # 斜体

DRAW_NAME         = true                              # 名前の描画
DRAW_HP           = true                              # HP の描画
DRAW_SP           = true                              # SP の描画

DRAW_WIDTH        =  80                               # 描画幅
DRAW_HEIGHT       = 3 * 32                            # 描画高さ
DRAW_SPACE        =   0                               # 行間
DRAW_Y            =  24                               # Y 座標修正値
end


#==============================================================================
# ■ Sprite_Battler
#==============================================================================

class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_initialize initialize
def initialize(viewport, battler = nil)
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_initialize(viewport, battler)
  # エネミーの場合
  if @battler.is_a?(Game_Enemy)
    width = PLAN_HPSP_DRAW::DRAW_WIDTH + 32
    height = PLAN_HPSP_DRAW::DRAW_HEIGHT + 32
    x = @battler.screen_x - width / 2
    y = @battler.screen_y - height + 32 + PLAN_HPSP_DRAW::DRAW_Y
    @enemy_hpsp_window = Window_Base.new(x, y, width, height)
    @enemy_hpsp_window.contents = Bitmap.new(width - 32, height - 32)
    @enemy_hpsp_window.contents.font.name = PLAN_HPSP_DRAW::FONT_NAME
    @enemy_hpsp_window.contents.font.size = PLAN_HPSP_DRAW::FONT_SIZE
    @enemy_hpsp_window.contents.font.bold = PLAN_HPSP_DRAW::FONT_BOLD
    @enemy_hpsp_window.contents.font.italic = PLAN_HPSP_DRAW::FONT_ITALIC
    y = 0
    @old_enemy_hpsp = []
    one_line = ((PLAN_HPSP_DRAW::FONT_SIZE * 100 / 28) * 32) / 100
    if PLAN_HPSP_DRAW::DRAW_NAME
      @enemy_hpsp_window.draw_actor_name(@battler, 0, y, width - 32)
      y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
      @old_enemy_hpsp.push(@battler.name)
    end
    if PLAN_HPSP_DRAW::DRAW_HP
      @enemy_hpsp_window.draw_actor_hp(@battler, 0, y, width - 32)
      y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
      @old_enemy_hpsp.push(@battler.hp)
    end
    if PLAN_HPSP_DRAW::DRAW_SP
      @enemy_hpsp_window.draw_actor_sp(@battler, 0, y, width - 32)
      @old_enemy_hpsp.push(@battler.sp)
    end
    @enemy_hpsp_window.opacity = 0
    @enemy_hpsp_window.contents_opacity = 0
    @enemy_hpsp_window.z = -2
  end
end
#--------------------------------------------------------------------------
# ● 解放
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_dispose dispose
def dispose
  # エネミーの場合
  if @battler.is_a?(Game_Enemy)
    @enemy_hpsp_window.dispose
  end
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_dispose
end
#--------------------------------------------------------------------------
# ● フレーム更新
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_update update
def update
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_update
  # エネミーの場合
  if @battler.is_a?(Game_Enemy)
    @enemy_hpsp_window.visible = @battler_visible
  # スプライトの座標を設定
    width = PLAN_HPSP_DRAW::DRAW_WIDTH + 32
    @enemy_hpsp_window.x = self.x - width / 2
    @now_enemy_hpsp = []
    if PLAN_HPSP_DRAW::DRAW_NAME
      @now_enemy_hpsp.push(@battler.name)
    end
    if PLAN_HPSP_DRAW::DRAW_HP
      @now_enemy_hpsp.push(@battler.hp)
    end
    if PLAN_HPSP_DRAW::DRAW_SP
      @now_enemy_hpsp.push(@battler.sp)
    end
    if @old_enemy_hpsp != @now_enemy_hpsp and $game_temp.enemy_hpsp_refresh
      @old_enemy_hpsp = @now_enemy_hpsp
      @enemy_hpsp_window.contents.clear
      y = 0
      width = PLAN_HPSP_DRAW::DRAW_WIDTH + 32
      one_line = ((PLAN_HPSP_DRAW::FONT_SIZE * 100 / 28) * 32) / 100
      if PLAN_HPSP_DRAW::DRAW_NAME
        @enemy_hpsp_window.draw_actor_name(@battler, 0, y, width - 32)
        y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
      end
      if PLAN_HPSP_DRAW::DRAW_HP
        @enemy_hpsp_window.draw_actor_hp(@battler, 0, y, width - 32)
        y += one_line + PLAN_HPSP_DRAW::DRAW_SPACE
      end
      if PLAN_HPSP_DRAW::DRAW_SP
        @enemy_hpsp_window.draw_actor_sp(@battler, 0, y, width - 32)
      end
      Graphics.frame_reset
    end
  end
end
#--------------------------------------------------------------------------
# ● visible の設定
#--------------------------------------------------------------------------
if !method_defined?("plan_enemy_hpsp_draw_visible=")
  alias plan_enemy_hpsp_draw_visible= visible=
end
def visible=(bool)
  # エネミーの場合
  if @battler.is_a?(Game_Enemy)
    @enemy_hpsp_window.visible = bool
  end
  # 元のメソッドに戻す
  self.plan_enemy_hpsp_draw_visible=(bool)
end
#--------------------------------------------------------------------------
# ● 不透明度の設定
#--------------------------------------------------------------------------
if !method_defined?("plan_enemy_hpsp_draw_opacity=")
  alias plan_enemy_hpsp_draw_opacity= opacity=
end
def opacity=(n)
  # 元のメソッドに戻す
  self.plan_enemy_hpsp_draw_opacity=(n)
  # エネミーの場合
  if @battler.is_a?(Game_Enemy)
    @enemy_hpsp_window.contents_opacity = n
  end
end
#--------------------------------------------------------------------------
# ● ダメージ
#--------------------------------------------------------------------------
def damage(value, critical)
  super(value, critical)
  bitmap = @_damage_sprite.bitmap
  @_damage_sprite.dispose
  @_damage_sprite = ::Sprite.new(Viewport.new(0, 0, 640, 480))
  @_damage_sprite.bitmap = bitmap
  @_damage_sprite.ox = 80
  @_damage_sprite.oy = 20
  @_damage_sprite.x = self.x
  @_damage_sprite.y = self.y - self.oy / 2
  @_damage_sprite.viewport.z = self.viewport.z + 1
  @_damage_sprite.z = 3000
  @_damage_duration = 40
end
#--------------------------------------------------------------------------
# ● ダメージ解放
#--------------------------------------------------------------------------
def dispose_damage
  if @_damage_sprite != nil
    @_damage_sprite.viewport.dispose
  end
  super
end
end





#==============================================================================
# ■ Game_Temp
#==============================================================================

class Game_Temp
#--------------------------------------------------------------------------
# ● 公開インスタンス変数
#--------------------------------------------------------------------------
attr_accessor :enemy_hpsp_refresh
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_initialize initialize
def initialize
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_initialize
  @enemy_hpsp_refresh = false
end
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================

class Scene_Battle
#--------------------------------------------------------------------------
# ● プレバトルフェーズ開始 (エネミー名＋アルファベット用)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_start_phase1 start_phase1
def start_phase1
  $game_temp.enemy_hpsp_refresh = true
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_start_phase1
end
#--------------------------------------------------------------------------
# ● パーティコマンドフェーズ開始 (エネミー名＋アルファベット用)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_start_phase2 start_phase2
def start_phase2
  $game_temp.enemy_hpsp_refresh = false
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_start_phase2
end
#--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズ ステップ 5 : ダメージ表示)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_update_phase4_step5 update_phase4_step5
def update_phase4_step5
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_update_phase4_step5
  $game_temp.enemy_hpsp_refresh = true
end
#--------------------------------------------------------------------------
# ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
#--------------------------------------------------------------------------
alias plan_enemy_hpsp_draw_update_phase4_step6 update_phase4_step6
def update_phase4_step6
  # 元のメソッドに戻す
  plan_enemy_hpsp_draw_update_phase4_step6
  $game_temp.enemy_hpsp_refresh = false
end
end


#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
#--------------------------------------------------------------------------
# ● 名前の描画
#--------------------------------------------------------------------------
def draw_actor_name(actor, x, y, width = 220, align = 0)
  if $scene.is_a?(Scene_Battle)
    flag = actor.name.sub!(/\*f/, '').nil? ? false : true
    self.contents.font.color = Color.new(0, 0, 0, 192)
  self.contents.draw_text(x+1, y, width, 32, actor.name, align)
  self.contents.draw_text(x, y+1, width, 32, actor.name, align)
end
  self.contents.font.color = normal_color
  self.contents.draw_text(x, y, width, 32, actor.name, align)
end

alias draw_actor_hp_original draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
   # Calculate if there is draw space for MaxHP
   if width - 32 >= 108
     hp_x = x + width - 108
     flag = true
   elsif width - 32 >= 48
     hp_x = x + width - 48
     flag = false
   end
   # Draw Shadow Effects for Battles
   if $scene.is_a?(Scene_Battle)
     self.contents.font.color = Color.new(0, 0, 0, 192)
     self.contents.draw_text(x, y+1, 32, 32, $data_system.words.hp)
     self.contents.draw_text(x+1, y, 32, 32, $data_system.words.hp)
     self.contents.draw_text(hp_x, y+1, 48, 32, actor.hp.to_s, 2)
     self.contents.draw_text(hp_x+1, y, 48, 32, actor.hp.to_s, 2)
   if flag
     self.contents.draw_text(hp_x + 49, y, 12, 32, "/", 1)
     self.contents.draw_text(hp_x + 48, y+1, 12, 32, "/", 1)
     self.contents.draw_text(hp_x + 60, y+1, 48, 32, actor.maxhp.to_s)
     self.contents.draw_text(hp_x + 61, y, 48, 32, actor.maxhp.to_s)
   end
   end
   # Draw "HP" text string
   self.contents.font.color = system_color
   self.contents.draw_text(x, y, 32, 32, $data_system.words.hp)
   # Draw HP
   self.contents.font.color = actor.hp == 0 ? knockout_color :
     actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
   self.contents.draw_text(hp_x, y, 48, 32, actor.hp.to_s, 2)
   # Draw MaxHP
   if flag
     self.contents.font.color = normal_color
     self.contents.draw_text(hp_x + 48, y, 12, 32, "/", 1)
     self.contents.draw_text(hp_x + 60, y, 48, 32, actor.maxhp.to_s)
   end
 end
 
 alias draw_actor_sp_original draw_actor_sp
 def draw_actor_sp(actor, x, y, width = 144)
   # Calculate if there is draw space for MaxHP
   if width - 32 >= 108
     sp_x = x + width - 108
     flag = true
   elsif width - 32 >= 48
     sp_x = x + width - 48
     flag = false
   end
   # Draw Shadow Effects for Battles
   if $scene.is_a?(Scene_Battle)
     self.contents.font.color = Color.new(0, 0, 0, 192)
     self.contents.draw_text(x, y+1, 32, 32, $data_system.words.sp)
     self.contents.draw_text(x+1, y, 32, 32, $data_system.words.sp)
     self.contents.draw_text(sp_x, y+1, 48, 32, actor.sp.to_s, 2)
     self.contents.draw_text(sp_x+1, y, 48, 32, actor.sp.to_s, 2)
   if flag
     self.contents.draw_text(hp_x + 49, y, 12, 32, "/", 1)
     self.contents.draw_text(hp_x + 48, y+1, 12, 32, "/", 1)
     self.contents.draw_text(hp_x + 60, y+1, 48, 32, actor.maxsp.to_s)
     self.contents.draw_text(hp_x + 61, y, 48, 32, actor.maxsp.to_s)
   end
   end
   # Draw "SP" text string
   self.contents.font.color = system_color
   self.contents.draw_text(x, y, 32, 32, $data_system.words.sp)
   # Draw SP
   self.contents.font.color = actor.sp == 0 ? knockout_color :
     actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
   self.contents.draw_text(sp_x, y, 48, 32, actor.sp.to_s, 2)
   # Draw MaxSP
   if flag
     self.contents.font.color = normal_color
     self.contents.draw_text(sp_x + 48, y, 12, 32, "/", 1)
     self.contents.draw_text(sp_x + 60, y, 48, 32, actor.maxsp.to_s)
   end
 end

#--------------------------------------------------------------------------
# ● ステートの描画
#--------------------------------------------------------------------------
def draw_actor_state(actor, x, y, width = 120)
  # 元のメソッドに戻す
  text = make_battler_state_text(actor, width, true)
  self.contents.draw_text(x, y, width, 32, text, 1)
end
end