Schickes sideview KS RPG XP

  • #--------------------------------------------------------------------------
    # ™Sideview battle simple English version
    #
    # (C) copyright by http://rye.jp/ Date 2007/01/12 Ver alpha
    #--------------------------------------------------------------------------
    # Side view battle script walking graphic version Special Thanks by blz
    #--------------------------------------------------------------------------


    #--------------------------------------------------------------------------
    # Standard of graphic file
    #--------------------------------------------------------------------------
    # battler graphics
    #
    # @Walking graphic is used as it is.
    # @
    # weapon graphics
    #
    # @The icon graphic of arms is used as it is.
    #



    module Side_view
    #--------------------------------------------------------------------------
    # œ Using together RTAB@™Automatic recognition
    #--------------------------------------------------------------------------
    if Scene_Battle.method_defined?("synthe?")
    RTAB = true
    else
    RTAB = false
    end
    #--------------------------------------------------------------------------
    # œ Using together RTAB cam ™Automatic recognition
    #--------------------------------------------------------------------------
    def camera_correctness
    return false if !RTAB
    begin
    return $scene.drive
    rescue
    return false
    end
    end
    #--------------------------------------------------------------------------
    # œ The maximum number of parties
    #--------------------------------------------------------------------------
    Party_max = 4
    #--------------------------------------------------------------------------
    # œ Expansion rate of Battler graphic(actor exclusive use)
    #--------------------------------------------------------------------------
    CHAR_ZOOM = 1.0
    #--------------------------------------------------------------------------
    # œ Arrow cursor position correction
    #--------------------------------------------------------------------------
    ARROW_OX = 0
    ARROW_OY = 64
    #--------------------------------------------------------------------------
    # œ State name treated as flight (Array)
    #--------------------------------------------------------------------------
    FLY_STATES = ["Flying"]
    #--------------------------------------------------------------------------
    # œ Positional correction of combat screen party
    #--------------------------------------------------------------------------
    PARTY_X = 480 # X position of party
    PARTY_Y = 200 # Y position of party
    FORMATION_X = 32 # actor's interval X
    FORMATION_Y = 38 # actor's interval Y
    #--------------------------------------------------------------------------
    # œ ƒJƒXƒ^ƒ}ƒCƒY’è”
    #--------------------------------------------------------------------------
    NORMAL = "NORMAL"
    WALK_R = "WALK_R"
    WALK_L = "WALK_L"
    ATTACK = "ATTACK"
    ATTACK_R = "ATTACK_R"
    ATTACK_L = "ATTACK_L"
    MAGIC = "MAGIC"
    ITEM = "ITEM"
    # ƒAƒjƒ‚ÌÝ’è
    ANIME = {
    # [id,Loop?,speed,weapon visible,pattern freeze,Weapon Right or Left(using RTAB)]
    NORMAL => [1,true , 0,false, true ,"" ], # Standby usually
    WALK_R => [2,true , 6,false, false,"" ], # move Right
    WALK_L => [1,true , 6,false, false,"" ], # move Left
    ATTACK_R => [1,false, 6,true , false,"Right"],# attack by Right hand
    ATTACK_L => [1,false, 6,true , false,"Left"], # attack by Left hand
    MAGIC => [1,false, 6,false, false,"" ], # spell Magic
    ITEM => [1,false, 6,false, false,"" ], # using Item
    }

    # default (Do not change it)
    ANIME.default = [1,false,12,false,"",""]

    # ƒAƒNƒVƒ‡ƒ“Ý’è‚ÌŠÖ˜A•t‚¯
    ACTION_LIB = {
    "Hero Move" => "moving_setup",
    "Hero Graphic Change" => "change",
    "Throw Animation" => "flying",
    "main phase step 3" => "animation1",
    "main phase step 4" => "animation2",
    "Waiting" => "wait",
    "Graphic Reverse" => "reverse",
    "Afterimage ON" => "shadow_on",
    "Afterimage OFF" => "shadow_off",
    "Freeze ON" => "freeze",
    "Freeze OFF" => "freeze_lifting",
    "Display Animation" => "animation_start",
    "Play Sound Effect" => "play_se",
    }
    ACTION_LIB.default = "finish"


    # (Do not change it)
    DUAL_WEAPONS_ANIME = [ATTACK]



    # Arms display X coordinates
    BLZ_X = {
    0=>[0,0,0,0], # NO MOTION
    1=>[2,2,2,2], # Shake lowering
    2=>[15,10,0,0], # Piercing
    3=>[2,2,2,2], # Raising
    4=>[0,0,3,3], # Bow and gun
    5=>[0,0,0,0], # For addition
    6=>[0,0,0,0], # For addition
    7=>[0,0,0,0], # For addition
    8=>[0,0,0,0], # For addition
    }
    # Arms display Y coordinates
    BLZ_Y = {
    0=>[0,0,0,0], # NO MOTION
    1=>[6,6,6,6], # Shake lowering
    2=>[6,6,6,6], # Piercing
    3=>[6,6,6,6], # Raising
    4=>[8,8,8,8], # Bow and gun
    5=>[0,0,0,0], # For addition
    6=>[0,0,0,0], # For addition
    7=>[0,0,0,0], # For addition
    8=>[0,0,0,0], # For addition
    }
    # Arms display Angle
    BLZ_ANGLE = {
    0=>[0,0,0,0], # NO MOTION
    1=>[75-45*3,75-45*2,75-45*1,75-45*1], # Shake lowering
    2=>[45,45,45,45], # Piercing
    3=>[100-45*1,100-45*2,100-45*3,00-45*4], # Raising
    4=>[45,45,45,45], # Bow and gun
    5=>[0,0,0,0], # For addition
    6=>[0,0,0,0], # For addition
    7=>[0,0,0,0], # For addition
    8=>[0,0,0,0], # For addition
    }

    #--------------------------------------------------------------------------
    # œ SHAKE
    #--------------------------------------------------------------------------
    SHAKE_FILE = "SHAKE" # filename
    SHAKE_POWER = 5 # POWER
    SHAKE_SPEED = 5 # SPEED
    SHAKE_DURATION = 5 # DURATION
    #--------------------------------------------------------------------------
    # œ UPSIDE_DOWN
    #--------------------------------------------------------------------------
    UPSIDE_DOWN_FILE = "UPSIDE_DOWN" # filename
    #--------------------------------------------------------------------------
    # œ REVERSE
    #--------------------------------------------------------------------------
    REVERSE_FILE = "REVERSE" # filename
    #--------------------------------------------------------------------------
    # œ ‰ñ“]‚ÌÝ’è
    #--------------------------------------------------------------------------
    TURNING_FILE = "ROTATION" # filename
    TURNING_DIRECTION = 1 # Directioni1.Anti-clockwise, -1.clockwise)
    TURNING_SPEED = 40 # Speed
    TURNING_DURATION = 1 # Rotation frequency
    #--------------------------------------------------------------------------
    # œ ˆÚ“®‚ÌÝ’è
    #--------------------------------------------------------------------------
    MOVE_FILE = "MOVE" # filename
    MOVE_RETURN = 1 # Do you return to former position?
    MOVE_SPEED = 32 # Speed
    MOVE_COORDINATES = [0,-640] # Relative coordinates from former position
    #--------------------------------------------------------------------------
    # œ Add Animation (using RTAB)
    #--------------------------------------------------------------------------
    ADD_ANIME_FILE = "Add_ANIME" # filename
    ADD_ANIME_ID = 0 # Animation ID
    #--------------------------------------------------------------------------
    # œ using RTAB (Do not change it)
    #--------------------------------------------------------------------------
    def convert_battler
    return RTAB ? @active_actor : @active_battler
    end
    #--------------------------------------------------------------------------
    # œ using RTAB (Do not change it)
    #--------------------------------------------------------------------------
    def convert_battler2(*arg)
    return RTAB ? arg[0] : @active_battler
    end
    end


    #--------------------------------------------------------------------------
    # œ action performer
    #--------------------------------------------------------------------------
    module BattleActions

    # Because the one below is one example to the last
    # Please make it originally.


    Actions = {


    "Normal Attack" => [

    "main phase step 3",
    "Hero Graphic Change#WALK_L",
    "Hero Move#target,32,0,64,0",
    "Hero Graphic Change#NORMAL",
    "Waiting#5",
    "Hero Graphic Change#ATTACK",
    "Throw Animation",
    "main phase step 4",
    "Hero Graphic Change#WALK_L",
    "Play Sound Effect#016-Jump02,80,100",
    "Hero Move#self,0,0,18,4",
    "end"
    ],



    "One step advancement Attack" => [

    "main phase step 3",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,-32,0,12,0",
    "Hero Graphic Change#NORMAL",
    "Waiting#5",
    "Hero Graphic Change#ATTACK",
    "Throw Animation",
    "main phase step 4",
    "Hero Graphic Change#WALK_L",
    "Play Sound Effect#016-Jump02,80,100",
    "Hero Move#self,0,0,12,0",
    "end"
    ],


    "Enemy Attack" => [

    "main phase step 3",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,-36,0,12,0",
    "Hero Graphic Change#NORMAL",
    "Waiting#5",
    "Hero Graphic Change#ATTACK",
    "Throw Animation",
    "main phase step 4",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,0,0,12,0",
    "end"
    ],


    "Spell Magic" => [

    "main phase step 3",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,-32,0,4,0",
    "Hero Graphic Change#MAGIC",
    "Waiting#15",
    "Throw Animation",
    "main phase step 4",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,0,0,4,2",
    "end"
    ],


    "Using Item" => [

    "Hero Graphic Change#WALK_L",
    "Hero Move#self,-32,0,4,0",
    "main phase step 3",
    "Hero Graphic Change#ITEM",
    "Waiting#15",
    "Throw Animation",
    "main phase step 4",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,0,0,4,2",
    "end"
    ],

    "Using Skill" => [

    "Hero Graphic Change#WALK_L",
    "Hero Move#target_near,50,0,48,6",
    "Graphic Reverse",
    "Freeze ON#ATTACK#3",
    "main phase step 3",
    "Play Sound Effect#135-Light01,100,100",
    "Display Animation#self,42",
    "Waiting#15",
    "Graphic Reverse",
    "Afterimage ON",
    "Hero Move#target_far,-50,0,48,0",
    "main phase step 4",
    "Afterimage OFF",
    "Freeze OFF",
    "Hero Graphic Change#WALK_L",
    "Hero Move#self,0,0,48,1,0",
    "end"
    ],
    }


    end

    module RPG


    # Because the one below is one example to the last
    # Please make it originally.


    class Weapon
    #--------------------------------------------------------------------------
    # Weapon sctions. Set what weapons are a stand still weapon.
    #--------------------------------------------------------------------------
    def battle_actions
    case @id
    when 21 # Bronze Gun
    return BattleActions::Actions["One step advancement Attack"]
    end
    return BattleActions::Actions["Normal Attack"] # default
    end
    end
    class Skill
    #--------------------------------------------------------------------------
    # œ action performer
    #--------------------------------------------------------------------------
    def battle_actions
    if self.magic?
    return BattleActions::Actions["Spell Magic"] # default
    else
    return BattleActions::Actions["Using Skill"] # default
    end
    end
    end
    class Item
    #--------------------------------------------------------------------------
    # œ action performer
    #--------------------------------------------------------------------------
    def battle_actions
    return BattleActions::Actions["Using Item"] # default
    end
    end
    end
    class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # œ action performer
    #--------------------------------------------------------------------------
    def battle_actions
    return BattleActions::Actions["Enemy Attack"] # default
    end
    end
    module RPG
    =begin

    œ Setting of arms type

    The attribute of the name "WeaponType" is made, and it is applied to arms.
    The figure is written behind "WeaponType".
    @@
    Example.@WeaponType1@

    =end
    class Weapon
    #--------------------------------------------------------------------------
    # œ WeaponType
    #--------------------------------------------------------------------------
    def anime
    # Elemental
    element_name = "WeaponType"
    for i in @element_set
    if $data_system.elements[i] =~ /#{element_name}([+-]?[0-9]+)?(%)?/
    return $1.to_i
    end
    end
    # Weapon ID


    # Because the one below is one example to the last
    # Please make it originally.


    case @id
    when 1,2,3,4
    return 1 # (WeaponType) Refer from the 115th line to the 150th line.
    when 5,6,7,8
    return 2 # (WeaponType) Refer from the 115th line to the 150th line.
    end
    return 1 # defaut
    end
    end
    end
    =begin
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------

    @ Animation is thrown out from performar to target.
    Please make animation from the data base.


    [ Animation ID, Speed, Do you shuttle?, Straight line (false) or curve(true)]
    =end
    module RPG
    class Weapon
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
    # Example
    #case @id
    #when 34 # Boomerang
    # return [10,32,true,true]
    #when 17,18,19,20 # Arrow
    # return [40,32,false,false]
    #end
    return [0,0,false,false] # No throw
    end
    end
    class Skill
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
    # Example
    #case @id
    #when 34 # Boomerang
    # return [10,32,true,true]
    #when 17,18,19,20 # Arrow
    # return [40,32,false,false]
    #end
    return [0,0,false,false] # No throw
    end
    end
    class Item
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
    # Example
    #case @id
    #when 34 # Boomerang
    # return [10,32,true,true]
    #when 17,18,19,20 # Arrow
    # return [40,32,false,false]
    #end
    return [0,0,false,false] # No throw
    end
    end
    end


    class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # œ Throw Animation
    #--------------------------------------------------------------------------
    def flying_anime
    # Example
    #case @id
    #when 34 # Boomerang
    # return [10,32,true,true]
    #when 17,18,19,20 # Arrow
    # return [40,32,false,false]
    #end
    return [0,0,false,false] # No throw
    end
    end
    #==============================================================================
    # ¡ Game_Battler
    #==============================================================================
    class Game_Battler
    include Side_view
    #--------------------------------------------------------------------------
    # œ ’ljÁEŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
    #--------------------------------------------------------------------------
    attr_accessor :height # ‰æ‘œ‚Ì‚‚³
    attr_accessor :real_x # XÀ•W•â³
    attr_accessor :real_y # YÀ•W•â³
    attr_accessor :real_zoom # Šg‘å—¦
    attr_accessor :wait_count # ƒAƒjƒ[ƒVƒ‡ƒ“ ‘Ò‚¿ŽžŠÔ
    attr_accessor :wait_count2 # ƒAƒjƒ[ƒVƒ‡ƒ“ ‘Ò‚¿ŽžŠÔ2
    attr_accessor :pattern # ƒAƒjƒ[ƒVƒ‡ƒ“ ƒJƒEƒ“ƒgiƒLƒƒƒ‰)
    attr_accessor :shake # ƒVƒFƒCƒNŠJŽnƒtƒ‰ƒbƒO
    attr_accessor :reverse # ¶‰E”½“]ƒtƒ‰ƒbƒO
    attr_accessor :shadow # Žc‘œƒtƒ‰ƒbƒO
    attr_accessor :flash_flag # ‘M‚«ƒtƒ‰ƒbƒO
    attr_reader :ox # XÀ•W•â³
    attr_reader :oy # YÀ•W•â³
    attr_reader :flying_x # ‰“‹——£ƒAƒjƒXÀ•W
    attr_reader :flying_y # ‰“‹——£ƒAƒjƒYÀ•W
    attr_reader :flying_anime # ‰“‹——£ƒAƒjƒ
    attr_reader :animation1_on # s“®ƒAƒjƒŠJŽnƒtƒ‰ƒbƒO
    attr_reader :animation2_on # ‘ÎÛƒAƒjƒŠJŽnƒtƒ‰ƒbƒO
    #--------------------------------------------------------------------------
    # œ ƒfƒtƒHƒ‹ƒg‚̃Aƒjƒ[ƒVƒ‡ƒ“‘Ò‚¿ŽžŠÔ‚ðŽæ“¾
    #--------------------------------------------------------------------------
    def animation_duration=(animation_duration)
    @_animation_duration = animation_duration
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹ŠJŽnŽž‚̃ZƒbƒgƒAƒbƒv
    #--------------------------------------------------------------------------
    def start_battle
    @height = 0
    @real_x = 0
    @real_y = 0
    @real_zoom = 1.0
    @battler_condition = ""
    @action = nil
    @battle_actions = []
    @battler_action = false
    @step = 0
    @anime_on = false
    @wait_count = 0
    @wait_count2 = 0
    @ox = 0
    @oy = 0
    @pattern = 0
    @pattern_log = true
    @pattern_freeze = false
    @condition_freeze = false
    @active = false
    @move_distance = nil
    @move_wait = 0
    @move_coordinates = [0,0,0,0]
    @flying_distance = nil
    @flying_wait = 0
    @flying_x = 0
    @flying_y = 0
    @flash_flag = {}
    self.flying_clear
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®’†”»’è
    #--------------------------------------------------------------------------
    def moving?
    # XÀ•W•â³‚Ü‚½‚ÍAYÀ•W•â³‚ª0‚Å‚È‚¯‚ê‚ÎAˆÚ“®’†
    return (@ox != 0 or @oy != 0)
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®I—¹”»’è
    #--------------------------------------------------------------------------
    def move_end?
    return (@ox == @move_coordinates[0] and @oy == @move_coordinates[1])
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒ“ŠJŽnÝ’è
    #--------------------------------------------------------------------------
    def action(flag = true)
    @battler_action = flag
    @animation1_on = false
    @animation2_on = false
    @step = "setup"
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒ“’†”»’è
    #--------------------------------------------------------------------------
    def action?
    return @battler_action
    end
    #--------------------------------------------------------------------------
    # œ ‘M‚«”»’è
    #--------------------------------------------------------------------------
    def flash?
    return @flash_flg
    end
    #--------------------------------------------------------------------------
    # œ 퓬•s”\”»’è
    #--------------------------------------------------------------------------
    def anime_dead?
    if $game_temp.in_battle and !RTAB
    if [2,3,4,5].include?($scene.phase4_step)
    return @last_dead
    end
    end
    return @last_dead = self.dead?
    end
    #--------------------------------------------------------------------------
    # œ ƒsƒ“ƒ`ó‘Ô”»’è
    #--------------------------------------------------------------------------
    def crisis?
    if $game_temp.in_battle and !RTAB
    if [2,3,4,5].include?($scene.phase4_step)
    return @last_crisis
    end
    end
    return @last_crisis = (self.hp <= self.maxhp / 4 or badstate?)
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒbƒhƒXƒe[ƒg”»’è
    #--------------------------------------------------------------------------
    def badstate?
    for i in @states
    unless $data_states[i].nonresistance
    return true
    end
    end
    return false
    end
    #--------------------------------------------------------------------------
    # œ ”òs
    #--------------------------------------------------------------------------
    def fly
    if @fly != nil
    return @fly
    end
    for id in @states
    if FLY_STATES.include?($data_states[id].name)
    return 60
    end
    end
    return 0
    end
    #--------------------------------------------------------------------------
    # œ ‰“‹——£ƒAƒjƒ–Ú•WÀ•W‚ÌŒvŽZ
    #--------------------------------------------------------------------------
    def flying_setup
    # “ñ“x–Ú‚ÍŽÀs‚µ‚È‚¢
    return if @flying_distance != nil && !camera_correctness
    if RTAB
    targets = @target
    else
    targets = $scene.target_battlers
    end
    # –Ú“IÀ•W‚ðŒvŽZ
    @f_target_x = 0
    @f_target_y = 0
    for t in targets
    @f_target_x += t.screen_x
    @f_target_y += t.screen_y
    end
    if targets != []
    @f_target_x /= targets.size
    @f_target_y /= targets.size
    else
    @flying_distance = 0
    return
    end
    # ‹——£‚ÌŒvŽZ
    @flying_distance = (self.screen_x - @f_target_x).abs + (self.screen_y - @f_target_y).abs
    @flying_end = false
    end
    #--------------------------------------------------------------------------
    # œ ‰“‹——£ƒAƒjƒ
    #--------------------------------------------------------------------------
    def flying_animation
    # –ß‚é
    if @step != "flying" or @flying_distance.nil?
    return [false,true]
    end
    # ‚ ‚ç‚©‚¶‚ߌvŽZ
    self_x = self.screen_x
    self_y = self.screen_y
    @flying_distance = @flying_distance == 0 ? 1 : @flying_distance
    n1 = @flying_wait / @flying_distance.to_f
    if @flying_distance - @flying_wait > @flying_distance / 2
    n2 = 1.0 + 10.0 * @flying_wait / @flying_distance.to_f
    else
    n2 = 1.0 + 10.0 * (@flying_distance - @flying_wait) / @flying_distance.to_f
    end
    if !@flying_anime[4]
    # ’¼üˆÚ“®
    x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
    y = (self_y + 1.0 * (@f_target_y - self_y) * n1).to_i
    else
    # ‹ÈüˆÚ“®
    if !@flying_proceed_end
    x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
    y = (self_y + 1.0 * (@f_target_y - self_y) * n1 - n2**2).to_i
    else
    x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
    y = (self_y + 1.0 * (@f_target_y - self_y) * n1 + n2**2).to_i
    end
    end
    # À•W‘ã“ü
    @flying_x = x
    @flying_y = y
    # ƒEƒGƒCƒg
    if !@flying_proceed_end
    # ŠJŽn
    @flying_proceed_start = @flying_wait == 0
    @flying_wait += @flying_anime[1]
    @flying_wait = [@flying_wait,@flying_distance].min
    @flying_proceed_end = @flying_wait == @flying_distance
    else
    # ŠJŽn
    @flying_return_start = @flying_wait == @flying_distance
    @flying_wait -= @flying_anime[1]
    @flying_wait = [@flying_wait,0].max
    @flying_return_end = @flying_wait == 0
    end
    if @flying_anime[1] == 0
    @flying_end = true
    elsif !@flying_anime[2]
    @flying_end = @flying_proceed_end
    else
    @flying_end = @flying_return_end
    end
    # ’l‚ð•Ô‚·iƒAƒjƒŠJŽn,ƒAƒjƒI—¹)
    return [@flying_proceed_start,@flying_end]
    end
    #--------------------------------------------------------------------------
    # œ ‰“‹——£ƒAƒjƒ‰Šú‰»
    #--------------------------------------------------------------------------
    def flying_clear
    @flying_proceed_start = false
    @flying_proceed_end = false
    @flying_return_start = false
    @flying_return_end = false
    @flying_end = true
    @flying_anime = [0,0,false,false]
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®
    #--------------------------------------------------------------------------
    def move
    # ‹——£‚ÌŒvŽZ
    @move_distance = (@move_coordinates[2] - @move_coordinates[0]).abs +
    (@move_coordinates[3] - @move_coordinates[1]).abs
    if @move_distance > 0
    return if @ox == @move_coordinates[0] and @oy == @move_coordinates[1]
    array = @move_coordinates
    # ƒWƒƒƒ“ƒv•â³’l‚ÌŒvŽZ
    n = 100.0 * @move_wait / @move_distance
    jump = -@move_action[4] * n * (100 - n) / 100.0
    @ox = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @move_wait) / @move_distance.to_f).to_i
    @oy = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @move_wait) / @move_distance.to_f + jump).to_i
    # ƒEƒGƒCƒg
    @move_wait -= @move_action[3]
    @move_wait = [@move_wait,0].max
    end
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®ƒAƒNƒVƒ‡ƒ“‚̎擾
    #--------------------------------------------------------------------------
    def get_move_action
    string = @action.split(/#/)[1]
    string = string.split(/,/)
    @move_action = [string[0],string[1].to_i,string[2].to_i,string[3].to_i,string[4].to_i,string[5].to_i]
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒ“‚̎擾
    #--------------------------------------------------------------------------
    def get_step
    if @action.nil?
    @step = "finish"
    return
    end
    return ACTION_LIB[@action.split(/#/)[0]]
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ŽŸ‚̃AƒNƒVƒ‡ƒ“‚Ö)
    #--------------------------------------------------------------------------
    def update_next
    @action = @battle_actions.shift
    @step = get_step
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (“®ìŽæ“¾)
    #--------------------------------------------------------------------------
    def update_setup
    # ƒAƒNƒVƒ‡ƒ“‚̎擾
    self.get_actions
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ˆÚ“®Žæ“¾)
    #--------------------------------------------------------------------------
    def update_moving_setup
    # ˆÚ“®ƒAƒNƒVƒ‡ƒ“‚̎擾
    self.get_move_action
    # ˆÚ“®–Ú•W‚ÌÝ’è
    self.move_setup
    @step = "moving"
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ˆÚ“®)
    #--------------------------------------------------------------------------
    def update_moving
    # ˆÚ“®
    self.move
    self.condition = @battler_condition
    # ˆÚ“®Š®—¹‚µ‚½‚玟‚̃Xƒeƒbƒv‚Ö
    if move_end?
    update_next
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒAƒjƒŽÀs)
    #--------------------------------------------------------------------------
    def update_action
    con = @action.split(/#/)[1]
    # ‰EŽèE¶Žè‚𕪂¯‚é
    if DUAL_WEAPONS_ANIME.include?(con)
    if !@first_weapon and @second_weapon
    con = con + "_L"
    else
    con = con + "_R"
    end
    end
    # ƒAƒjƒ•ÏX
    self.condition = con
    # ƒ‹[ƒv‚©”Û‚©
    if !ANIME[@battler_condition][1]
    self.anime_on
    end
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (‰“‹——£ƒAƒjƒ)
    #--------------------------------------------------------------------------
    def update_flying
    # –Ú•W‚ÌÝ’è
    self.flying_setup
    # ‰“‹——£ƒAƒjƒI—¹
    if @flying_end or @flying_anime == [0,0,false,false]
    self.flying_clear
    update_next
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒAƒjƒ•ÏX)
    #--------------------------------------------------------------------------
    def update_change
    con = @action.split(/#/)[1]
    # ‰EŽèE¶Žè‚𕪂¯‚é
    if DUAL_WEAPONS_ANIME.include?(con)
    if !@first_weapon and @second_weapon
    con = con + "_L"
    else
    con = con + "_R"
    end
    end
    # ƒAƒjƒ•ÏX
    self.condition = con
    # ƒ‹[ƒv‚©”Û‚©
    if !ANIME[@battler_condition][1]
    self.anime_on
    end
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (s“®ƒAƒjƒ)
    #--------------------------------------------------------------------------
    def update_animation1
    @animation1_on = true
    # s“®ƒAƒjƒ‚ÌŒã‚És“®‚ðŠJŽn‚·‚é
    if $scene.phase4_step == 3
    id = RTAB ? @anime1 : $scene.animation1_id
    animation = $data_animations[id]
    frame_max = animation != nil ? animation.frame_max : 0
    @wait_count2 = frame_max * 2
    return
    end
    update_next
    end

  • #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒEƒGƒCƒg)
    #--------------------------------------------------------------------------
    def update_wait
    @wait_count2 = @action.split(/#/)[1].to_i
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (Žc‘œ•\Ž¦)
    #--------------------------------------------------------------------------
    def update_shadow_on
    @shadow = true
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (Žc‘œÁ‹Ž)
    #--------------------------------------------------------------------------
    def update_shadow_off
    @shadow = false
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (¶‰E”½“])
    #--------------------------------------------------------------------------
    def update_reverse
    @reverse = @reverse ? false : true
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (‘M‚«ƒAƒjƒ)
    #--------------------------------------------------------------------------
    def update_flash
    # ‘M‚«ƒAƒjƒ‚ÌŒã‚És“®‚ðŠJŽn‚·‚é
    if @flash_flag["normal"]
    @wait_count = $scene.flash_duration
    @flash_flag["normal"] = false
    return
    end
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (SE‚̉‰‘t)
    #--------------------------------------------------------------------------
    def update_play_se
    data = @action.split(/#/)[1]
    data = data.split(/,/)
    # SE ‚ð‰‰‘t
    Audio.se_play("Audio/SE/" + data[0], data[1].to_i, data[2].to_i)
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ’è)
    #--------------------------------------------------------------------------
    def update_freeze
    con = @action.split(/#/)[1]
    # ‰EŽèE¶Žè‚𕪂¯‚é
    if DUAL_WEAPONS_ANIME.include?(con)
    if !@first_weapon and @second_weapon
    con = con + "_L"
    else
    con = con + "_R"
    end
    end
    # ƒAƒjƒ•ÏX
    self.condition = con
    @pattern = @action.split(/#/)[2].to_i
    @pattern_freeze = true
    @condition_freeze = true
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ’è‰ðœ)
    #--------------------------------------------------------------------------
    def update_freeze_lifting
    @pattern_freeze = false
    @condition_freeze = false
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒAƒjƒ[ƒVƒ‡ƒ“‚Ì•\Ž¦)
    #--------------------------------------------------------------------------
    def update_animation_start
    data = @action.split(/#/)[1]
    data = data.split(/,/)
    target = data[0]
    animation_id = data[1].to_i
    if RTAB
    case target
    when "self"
    @animation.push([animation_id,true])
    when "target"
    for tar in @target
    tar.animation.push([animation_id, true])
    end
    end
    else
    case target
    when "self"
    @animation_id = animation_id
    @animation_hit = true
    when "target"
    for tar in $scene.target_battlers
    tar.animation_id = animation_id
    tar.animation_hit = true
    end
    end
    end
    update_next
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (“®ìI—¹)
    #--------------------------------------------------------------------------
    def update_finish
    # “®ìI—¹
    @battler_action = false
    @step = "setup"
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‰[‚Ìó‘Ôiƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN‚̃^ƒCƒv)
    #--------------------------------------------------------------------------
    def condition
    return @battler_condition
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‰[‚Ìó‘Ô •ÏXiƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN‚̃^ƒCƒv)
    #--------------------------------------------------------------------------
    def condition=(condition)
    return if @condition_freeze
    if @battler_condition != condition
    @wait_count = ANIME[condition][2]
    @pattern = 0
    end
    @battler_condition = condition
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    def update
    # ƒEƒFƒCƒg’†‚Ìê‡
    if @wait_count == 0
    # ƒpƒ^[ƒ“XV
    self.char_animation
    @wait_count = ANIME[@battler_condition][2]
    end
    # ƒpƒ^[ƒ“XV
    self.char_animation
    # ƒEƒFƒCƒg’†‚Ìê‡
    if @wait_count2 > 0
    return
    end

    # s“®ƒAƒjƒ[ƒVƒ‡ƒ“
    if @battler_action
    method("update_" + @step).call
    return
    end

    # ƒf[ƒ^‰Šú‰»
    @animation1_on = false
    @animation2_on = false
    @action = nil
    @battle_actions = []
    @move_wait = 0
    @move_distance = nil
    @flying_wait = 0
    @flying_distance = nil
    @flash = false


    # ’ÊíE‘Ò‹@
    return self.condition = NORMAL
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒVƒ‡ƒ“‚̎擾
    #--------------------------------------------------------------------------
    def get_actions
    skill = $data_skills[self.current_action.skill_id]
    item = $data_items[self.current_action.item_id]
    kind = self.current_action.kind
    # “®ìŽæ“¾
    @battle_actions = []
    # ƒXƒLƒ‹
    if skill != nil && kind == 1
    @battle_actions = skill.battle_actions.dup
    @flying_anime = skill.flying_anime
    # ƒAƒCƒeƒ€
    elsif item != nil && kind == 2
    @battle_actions = item.battle_actions.dup
    @flying_anime = item.flying_anime
    # ¶ŽèUŒ‚
    elsif !@first_weapon and @second_weapon and self.is_a?(Game_Actor)
    @battle_actions = self.battle_actions2.dup
    @flying_anime = self.flying_anime2
    # ‰EŽèUŒ‚
    elsif self.current_action.basic == 0 and
    self.is_a?(Game_Actor) and self.current_action.kind == 0
    @battle_actions = self.battle_actions1.dup
    @flying_anime = self.flying_anime1
    # ’ÊíUŒ‚
    elsif self.current_action.basic == 0 and self.current_action.kind == 0
    @battle_actions = self.battle_actions.dup
    @flying_anime = self.flying_anime
    else
    @battle_actions = ["I—¹"]
    @flying_anime = [0,0,false,false]
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒ‹[ƒv‚µ‚È‚¢ƒAƒjƒ‚̃Zƒbƒg
    #--------------------------------------------------------------------------
    def anime_on
    @pattern = 0
    @pattern_log = true
    return
    end
    #--------------------------------------------------------------------------
    # œ ƒpƒ^[ƒ“XV
    #--------------------------------------------------------------------------
    def char_animation
    # ƒpƒ^ƒ“ŒÅ’è‚Ìꇂà‚Ç‚é
    return if @pattern_freeze
    # ƒ‹[ƒv‚µ‚È‚¢ƒAƒjƒ‚Ìê‡ 1234 ‚ÅŽ~‚Ü‚é
    if !ANIME[@battler_condition][1] && @pattern == 3
    return
    end
    # ƒAƒjƒ‚³‚¹‚È‚¢ê‡ 1 ‚ÅŽ~‚Ü‚é
    if ANIME[@battler_condition][4]
    @pattern = 0
    return
    end
    @pattern = (@pattern + 1) % 4
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒjƒƒ^ƒCƒv
    #--------------------------------------------------------------------------
    def anime_type
    return ANIME[@battler_condition] != nil ? ANIME[@battler_condition][0] : 0
    end
    end
    #==============================================================================
    # ¡ Game_Actor
    #==============================================================================
    class Game_Actor < Game_Battler
    include Side_view
    #--------------------------------------------------------------------------
    # œ ƒZƒbƒgƒAƒbƒv
    #--------------------------------------------------------------------------
    alias side_view_setup setup
    def setup(actor_id)
    side_view_setup(actor_id)
    start_battle
    end
    #--------------------------------------------------------------------------
    # œ “ñ“•Ší‚ÌIDŽæ“¾@¦ƒGƒ‰[‰ñ”ð—p
    #--------------------------------------------------------------------------
    def weapon2_id
    return @weapon2_id != nil ? @weapon2_id : 0
    end
    #--------------------------------------------------------------------------
    # œ X•ûŒü ƒ|ƒWƒVƒ‡ƒ“ Žæ“¾
    #--------------------------------------------------------------------------
    def position
    return $data_classes[@class_id].position
    end
    #--------------------------------------------------------------------------
    # œ Y•ûŒü ƒ|ƒWƒVƒ‡ƒ“ Žæ“¾
    #--------------------------------------------------------------------------
    def position2
    return self.index
    end
    #--------------------------------------------------------------------------
    # œ •ŠíƒAƒjƒƒ^ƒCƒv
    #--------------------------------------------------------------------------
    def weapon_anime_type(type = @battler_condition)
    file_name = weapon_anime_type0(type)
    visible = weapon_anime_type1(type)
    z = weapon_anime_type2(type)
    motion = weapon_anime_type3(type)
    return [file_name,visible,z,motion]
    end
    # •ŠíƒAƒCƒRƒ“Žæ“¾
    def weapon_anime_type0(type = @battler_condition)
    type = ANIME[type][5]
    return weapon_anime1 if type == "Right"
    return weapon_anime2 if type == "Left"
    return nil
    end
    # •\Ž¦E”ñ•\Ž¦‚̎擾
    def weapon_anime_type1(type = @battler_condition)
    return ANIME[type][3]
    end
    # ƒoƒgƒ‰[‚æ‚èã‚É•\Ž¦‚·‚é‚©‚Ç‚¤‚©
    def weapon_anime_type2(type = @battler_condition)
    type = ANIME[type][5]
    return true if type == "Left"
    return false
    end
    # •Ší‚Ì“®ìNoDŽæ“¾
    def weapon_anime_type3(type = @battler_condition)
    type = ANIME[type][5]
    return extend_weapon_anime1 if type == "Right"
    return extend_weapon_anime2 if type == "Left"
    return 0
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
    #--------------------------------------------------------------------------
    def true_x
    return PARTY_X + position * FORMATION_X + @ox
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
    #--------------------------------------------------------------------------
    def true_y
    # ƒp[ƒeƒB“à‚Ì•À‚ч‚©‚ç Y À•W‚ðŒvŽZ‚µ‚Ä•Ô‚·
    if self.index != nil
    y = position2 * FORMATION_Y + PARTY_Y + @oy - @height / 2
    return y
    else
    return 0
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
    #--------------------------------------------------------------------------
    def screen_x(true_x = self.true_x)
    return 320 + (true_x - 320) * @real_zoom + @real_x
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
    #--------------------------------------------------------------------------
    def screen_y(true_y = self.true_y)
    return true_y * @real_zoom + @real_y
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Z À•W‚̎擾
    #--------------------------------------------------------------------------
    def screen_z
    return screen_y + 1000
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
    #--------------------------------------------------------------------------
    def base_x
    return 320 + (true_x - @ox - 320) * @real_zoom + @real_x
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
    #--------------------------------------------------------------------------
    def base_y
    return (true_y - @oy) * @real_zoom + @real_y
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Šg‘å—¦‚̎擾
    #--------------------------------------------------------------------------
    def zoom
    return ($scene.zoom_rate[1] - $scene.zoom_rate[0]) *
    (true_x + @fly) / 480 + $scene.zoom_rate[0]
    end
    #--------------------------------------------------------------------------
    # œ UŒ‚—pAƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
    #--------------------------------------------------------------------------
    def attack_x(z)
    return (320 - true_x) * z * 0.75
    end
    #--------------------------------------------------------------------------
    # œ UŒ‚—pAƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
    #--------------------------------------------------------------------------
    def attack_y(z)
    return (160 - (true_y + fly / 4) * z + @height * zoom * z / 2) * 0.75
    end
    #--------------------------------------------------------------------------
    # œ ‘M‚«‘Ò‚¿ŽžŠÔ
    #--------------------------------------------------------------------------
    def flash_duration
    return $scene.flash_duration
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
    #--------------------------------------------------------------------------
    def battle_actions1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.battle_actions : BattleActions::Actions["’ÊíUŒ‚"]
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
    #--------------------------------------------------------------------------
    def battle_actions2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.battle_actions : BattleActions::Actions["’ÊíUŒ‚"]
    end
    #--------------------------------------------------------------------------
    # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“ “®‚«•û Žæ“¾
    #--------------------------------------------------------------------------
    def extend_weapon_anime1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.anime : 0
    end
    #--------------------------------------------------------------------------
    # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“ “®‚«•û Žæ“¾
    #--------------------------------------------------------------------------
    def extend_weapon_anime2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.anime : 0
    end
    #--------------------------------------------------------------------------
    # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
    #--------------------------------------------------------------------------
    def weapon_anime1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.icon_name : ""
    end
    #--------------------------------------------------------------------------
    # œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
    #--------------------------------------------------------------------------
    def weapon_anime2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.icon_name : ""
    end
    #--------------------------------------------------------------------------
    # œ ‰“‹——£ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
    #--------------------------------------------------------------------------
    def flying_anime1
    weapon = $data_weapons[@weapon_id]
    return weapon != nil ? weapon.flying_anime : [0,0,false,false]
    end
    #--------------------------------------------------------------------------
    # œ ‰“‹——£ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
    #--------------------------------------------------------------------------
    def flying_anime2
    weapon = $data_weapons[@weapon2_id]
    return weapon != nil ? weapon.flying_anime : [0,0,false,false]
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®–Ú•WÀ•W‚ÌŒvŽZ
    #--------------------------------------------------------------------------
    def move_setup
    if RTAB
    targets = @target
    else
    targets = $scene.target_battlers
    end
    case @move_action[0]
    when "self" # Ž©•ª
    @target_x = self.base_x
    @target_y = self.base_y
    when "target_near" # ˆê”Ô‹ß‚­‚̃^[ƒQƒbƒg
    targets.sort!{|a,b| a.screen_x<=>b.screen_x }
    targets.reverse!
    if targets != []
    @target_x = targets[0].screen_x
    @target_y = targets[0].screen_y
    else
    @target_x = self.base_x
    @target_y = self.base_y
    end
    when "target_far" # ˆê”Ô‰“‚­‚̃^[ƒQƒbƒg
    targets.sort!{|a,b| a.screen_x<=>b.screen_x }
    if targets != []
    @target_x = targets[0].screen_x
    @target_y = targets[0].screen_y
    else
    @target_x = self.base_x
    @target_y = self.base_y
    end
    when "target" # ƒ^[ƒQƒbƒg’†‰›
    @target_x = 0
    @target_y = 0
    for t in targets
    @target_x += t.screen_x
    @target_y += t.screen_y
    end
    if targets != []
    @target_x /= targets.size
    @target_y /= targets.size
    end
    when "troop" # "ƒgƒ‹[ƒv’†‰›"
    @target_x = 0
    @target_y = 0
    for t in $game_troop.enemies
    @target_x += t.screen_x
    @target_y += t.screen_y
    end
    if $game_troop.enemies != []
    @target_x /= $game_troop.enemies.size
    @target_y /= $game_troop.enemies.size
    end
    when "party" # "ƒp[ƒeƒB’†‰›"
    @target_x = 0
    @target_y = 0
    for t in $game_party.actors
    @target_x += t.screen_x
    @target_y += t.screen_y
    end
    if $game_party.actors != []
    @target_x /= $game_party.actors.size
    @target_y /= $game_party.actors.size
    end
    when "screen" # "‰æ–Ê"
    @target_x = self.base_x
    @target_y = self.base_y
    end
    # •â³
    @target_x += @move_action[1] - self.base_x
    @target_y += @move_action[2] - self.base_y
    # ˆÚ“®–Ú•W‚ÌÀ•W‚ðƒZƒbƒg
    @move_coordinates = [@target_x.to_i,@target_y.to_i,@move_coordinates[0],@move_coordinates[1]]
    # ‹——£‚ÌŒvŽZ(ƒEƒGƒCƒg‚ÌÝ’è)
    @move_wait = (@move_coordinates[2] - @move_coordinates[0]).abs +
    (@move_coordinates[3] - @move_coordinates[1]).abs
    end
    end
    #==============================================================================
    # ¡ Game_Enemy
    #==============================================================================
    class Game_Enemy < Game_Battler
    #--------------------------------------------------------------------------
    # œ ƒZƒbƒgƒAƒbƒv
    #--------------------------------------------------------------------------
    alias side_view_initialize initialize
    def initialize(troop_id, member_index)
    side_view_initialize(troop_id, member_index)
    start_battle
    end
    def character_name
    return battler_name
    end
    def character_hue
    return battler_hue
    end
    def reverse
    return !@reverse
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®
    #--------------------------------------------------------------------------
    def move
    # ‹——£‚ÌŒvŽZ
    @move_distance = (@move_coordinates[2] - @move_coordinates[0]).abs +
    (@move_coordinates[3] - @move_coordinates[1]).abs
    if @move_distance > 0
    return if @ox == @move_coordinates[0] and @oy == @move_coordinates[1]
    array = @move_coordinates
    # ƒWƒƒƒ“ƒv•â³’l‚ÌŒvŽZ
    n = 100.0 * @move_wait / @move_distance
    jump = -@move_action[4] * n * (100 - n) / 100.0
    @ox = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @move_wait) / @move_distance.to_f).to_i
    @oy = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @move_wait) / @move_distance.to_f + jump).to_i
    # ƒEƒGƒCƒg
    @move_wait -= @move_action[3]
    @move_wait = [@move_wait,0].max
    end
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®–Ú•WÀ•W‚ÌŒvŽZ
    #--------------------------------------------------------------------------
    def move_setup
    if RTAB
    targets = @target
    else
    targets = $scene.target_battlers
    end
    case @move_action[0]
    when "self" # Ž©•ª
    @target_x = self.base_x
    @target_y = self.base_y
    when "target_near" # ˆê”Ô‹ß‚­‚̃^[ƒQƒbƒg
    targets.sort!{|a,b| a.screen_x<=>b.screen_x }
    if targets != []
    @target_x = targets[0].screen_x
    @target_y = targets[0].screen_y
    else
    @target_x = self.base_x
    @target_y = self.base_y
    end
    when "target_far" # ˆê”Ô‰“‚­‚̃^[ƒQƒbƒg
    targets.sort!{|a,b| a.screen_x<=>b.screen_x }
    targets.reverse!
    if targets != []
    @target_x = targets[0].screen_x
    @target_y = targets[0].screen_y
    else
    @target_x = self.base_x
    @target_y = self.base_y
    end
    when "target" # ƒ^[ƒQƒbƒg’†‰›
    @target_x = 0
    @target_y = 0
    for t in targets
    @target_x += t.screen_x
    @target_y += t.screen_y
    end
    if targets != []
    @target_x /= targets.size
    @target_y /= targets.size
    end
    when "party" # "ƒgƒ‹[ƒv’†‰›"
    @target_x = 0
    @target_y = 0
    for t in $game_troop.enemies
    @target_x += t.screen_x
    @target_y += t.screen_y
    end
    if $game_troop.enemies != []
    @target_x /= $game_troop.enemies.size
    @target_y /= $game_troop.enemies.size
    end
    when "troop" # "ƒp[ƒeƒB’†‰›"
    @target_x = 0
    @target_y = 0
    for t in $game_party.actors
    @target_x += t.screen_x
    @target_y += t.screen_y
    end
    if $game_party.actors != []
    @target_x /= $game_party.actors.size
    @target_y /= $game_party.actors.size
    end
    when "screen" # "‰æ–Ê"
    @target_x = self.base_x
    @target_y = self.base_y
    end
    # •â³
    @target_x -= @move_action[1] + self.base_x
    @target_y -= @move_action[2] + self.base_y
    # ˆÚ“®–Ú•W‚ÌÀ•W‚ðƒZƒbƒg
    @move_coordinates = [@target_x.to_i,@target_y.to_i,@move_coordinates[0],@move_coordinates[1]]
    # ‹——£‚ÌŒvŽZ(ƒEƒGƒCƒg‚ÌÝ’è)
    @move_wait = (@move_coordinates[2] - @move_coordinates[0]).abs +
    (@move_coordinates[3] - @move_coordinates[1]).abs
    end
    if RTAB
    alias original_x true_x
    alias original_y true_y
    else
    alias original_x screen_x
    alias original_y screen_y
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
    #--------------------------------------------------------------------------
    def true_x
    return original_x + @ox
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
    #--------------------------------------------------------------------------
    def true_y
    return original_y - @height / 2 + @oy
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
    #--------------------------------------------------------------------------
    def screen_x(true_x = self.true_x)
    return true_x * @real_zoom + @real_x
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾
    #--------------------------------------------------------------------------
    def screen_y(true_y = self.true_y)
    return true_y * @real_zoom + @real_y
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
    #--------------------------------------------------------------------------
    def base_x(true_x = self.true_x)
    return (true_x - @ox) * @real_zoom + @real_x
    end
    #--------------------------------------------------------------------------
    # œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
    #--------------------------------------------------------------------------
    def base_y(true_y = self.true_y)
    return (true_y - @oy) * @real_zoom + @real_y
    end
    end
    #==============================================================================
    # ¡ Game_Party
    #==============================================================================
    class Game_Party
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒ^[‚ð‰Á‚¦‚é
    # actor_id : ƒAƒNƒ^[ ID
    #--------------------------------------------------------------------------
    alias side_view_add_actor add_actor
    def add_actor(actor_id)
    # ƒAƒNƒ^[‚ðŽæ“¾
    actor = $game_actors[actor_id]
    # ƒTƒCƒhƒrƒ…[ƒf[ƒ^‚̉Šú‰»
    actor.start_battle
    # –ß‚·
    side_view_add_actor(actor_id)
    end
    end
    #==============================================================================
    # ¡ Scene_Battle
    #==============================================================================
    class Scene_Battle
    include Side_view
    #--------------------------------------------------------------------------
    # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
    #--------------------------------------------------------------------------
    attr_reader :phase # ƒtƒF[ƒY
    attr_reader :phase4_step # ƒtƒF[ƒY‚SƒXƒeƒbƒv
    attr_reader :active_battler # ‘ÎÛ‚Ì”z—ñ
    attr_reader :target_battlers # ‘ÎÛ‚Ì”z—ñ
    attr_reader :animation1_id # s“®ƒAƒjƒID
    attr_reader :animation2_id # ‘ÎÛƒAƒjƒID
    #--------------------------------------------------------------------------
    # œ ƒƒCƒ“ˆ—
    #--------------------------------------------------------------------------
    alias side_view_main main
    def main
    # ƒoƒgƒ‰[‰Šú‰»
    for battler in $game_party.actors + $game_troop.enemies
    battler.start_battle
    end
    # –ß‚·
    side_view_main
    end
    #--------------------------------------------------------------------------
    # œ ‘M‚«”»’è
    #--------------------------------------------------------------------------
    def flash?
    return @flash_flag ? true : false
    end
    #--------------------------------------------------------------------------
    # œ ‘M‚«ƒAƒjƒ‘Ò‚¿ŽžŠÔŽæ“¾
    #--------------------------------------------------------------------------
    def flash_duration
    animation = nil
    if FLASH_ANIME
    animation = $data_animations[FLASH_ANIMATION_ID]
    end
    return animation != nil ? animation.frame_max * 2 + 2 : 0
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 2 : ƒAƒNƒVƒ‡ƒ“ŠJŽn)
    #--------------------------------------------------------------------------
    alias side_view_update_phase4_step2 update_phase4_step2
    def update_phase4_step2(*arg)
    battler = convert_battler2(*arg)
    battler.action
    side_view_update_phase4_step2(*arg)
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 3 : s“®‘¤ƒAƒjƒ[ƒVƒ‡ƒ“)
    #--------------------------------------------------------------------------
    alias side_view_update_phase4_step3 update_phase4_step3
    def update_phase4_step3(*arg)
    battler = convert_battler2(*arg)
    return if !battler.animation1_on and battler.action? and !battler.flash?
    if battler.flash? and FLASH_ANIME
    battler.flash_flag["normal"] = true
    end
    side_view_update_phase4_step3(*arg)
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 4 : ‘ÎÛ‘¤ƒAƒjƒ[ƒVƒ‡ƒ“)
    #--------------------------------------------------------------------------
    alias side_view_update_phase4_step4 update_phase4_step4
    def update_phase4_step4(*arg)
    battler = convert_battler2(*arg)
    targets = RTAB ? battler.target : @target_battlers
    return if !battler.animation2_on and battler.action?
    side_view_update_phase4_step4(*arg)
    for target in targets
    if RTAB
    value = nil
    if target.damage_sp.include?(battler)
    value = target.damage_sp[battler]
    end
    if target.damage.include?(battler)
    if value == nil or value == "Miss"
    value = target.damage[battler]
    elsif value.is_a?(Numeric) && value > 0
    value = target.damage[battler] == "Miss" ? value : target.damage[battler]
    end
    end
    else
    value = target.damage
    end
    if target.is_a?(Game_Actor)
    # ƒ_ƒ[ƒW‚Ìê‡
    if value.is_a?(Numeric) && value > 0
    # ƒVƒFƒCƒN‚ðŠJŽn
    target.shake = true
    end
    elsif target.is_a?(Game_Enemy)
    # ƒ_ƒ[ƒW‚Ìê‡
    if value.is_a?(Numeric) && value > 0
    # ƒVƒFƒCƒN‚ðŠJŽn
    target.shake = true
    end
    end
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒvƒŒƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
    #--------------------------------------------------------------------------
    alias start_phase1_correct start_phase1
    def start_phase1
    # ƒJƒƒ‰‚ÌÝ’è
    # Œ³Xƒtƒƒ“ƒgƒrƒ…[Œü‚¯‚Ì”’l‚É‚È‚Á‚Ä‚¢‚邽‚ß
    @zoom_rate = [1.0, 1.0]
    start_phase1_correct
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
    #--------------------------------------------------------------------------
    alias start_phase3_correct start_phase3
    def start_phase3
    battler = convert_battler
    start_phase3_correct
    if RTAB
    # ƒJƒƒ‰‚ÌÝ’è
    # Œ³Xƒtƒƒ“ƒgƒrƒ…[Œü‚¯‚Ì”’l‚É‚È‚Á‚Ä‚¢‚邽‚ß
    @camera = "command"
    @spriteset.screen_target(0, 0, 1.0)
    end
    end
    end


    class Spriteset_Battle
    include Side_view
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    #--------------------------------------------------------------------------
    alias side_veiw_initialize initialize
    def initialize
    side_veiw_initialize
    # ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ð‰ð•ú
    for sprite in @actor_sprites
    sprite.dispose
    end
    # ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ðì¬
    @actor_sprites = []
    for i in 1..Party_max
    @actor_sprites.push(Sprite_Battler.new(@viewport1))
    end
    update
    end
    #--------------------------------------------------------------------------
    # œ ‰æ–ʂ̃XƒNƒ[ƒ‹
    #--------------------------------------------------------------------------
    if method_defined?("screen_scroll")
    alias side_view_screen_scroll screen_scroll
    def screen_scroll
    side_view_screen_scroll
    # ƒAƒNƒ^[‚̈ʒu•â³
    for actor in $game_party.actors
    actor.real_x = @real_x
    actor.real_y = @real_y
    actor.real_zoom = @real_zoom
    end
    end
    end
    end


    class Sprite_Battler < RPG::Sprite
    include Side_view
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    # viewport : ƒrƒ…[ƒ|[ƒg
    # battler : ƒoƒgƒ‰[ (Game_Battler)
    #--------------------------------------------------------------------------
    def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    @weapon = Sprite_Weapon.new(viewport, battler)
    @flying = Sprite_Flying.new(viewport, battler)
    @shadow = []
    @fly = 0
    @fly_direction = 1
    @rand = rand(10)
    @bitmaps = {}
    self.effect_clear
    end
    #--------------------------------------------------------------------------
    # œ ‰ð•ú
    #--------------------------------------------------------------------------
    alias side_view_dispose dispose
    def dispose
    side_view_dispose
    @weapon.dispose if @weapon != nil
    @flying.dispose if @flying != nil
    if @_target_sprite != nil
    @_target_sprite.bitmap.dispose
    @_target_sprite.dispose
    @_target_sprite = nil
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚Ìê‡
    if @battler == nil
    self.bitmap = nil
    @weapon.bitmap = nil
    loop_animation(nil)
    return
    end
    # ƒoƒgƒ‰[XV
    @battler.update
    # ƒoƒgƒ‰[ƒAƒjƒ‚̃f[ƒ^Žæ“¾
    @anime_type = @battler.anime_type
    # bitmap ‚ðƒLƒƒƒbƒVƒ…‰»
    path = @anime_type[0].to_s + "#" + @battler.pattern.to_s
    if not @bitmaps.include?(path) or @bitmaps[path].disposed?
    # ƒtƒ@ƒCƒ‹–¼‚©F‘Š‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    change = (@battler.character_name != @battler_name or @battler.character_hue != @battler_hue)
    if change
    # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
    @battler_name = @battler.character_name
    @battler_hue = @battler.character_hue
    @bitmap = RPG::Cache.character(@battler_name, @battler_hue)
    @width = @bitmap.width / 4
    @height = @bitmap.height / 4
    self.ox = @width / 2
    self.oy = @height / 2
    @battler.height = @height
    @flag = true
    # 퓬•s”\‚Ü‚½‚͉B‚êó‘Ô‚È‚ç•s“§–¾“x‚ð 0 ‚É‚·‚é
    if @battler.dead? or @battler.hidden
    self.opacity = 0
    end
    end
    if (@anime_type[0] != @battler_condition or
    @battler.pattern != @battler_pattern or flag)
    # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
    @battler_condition = @anime_type[0]
    @battler_pattern = @battler.pattern
    @sx = @battler.pattern * @width
    @sy = @anime_type[0] % 4 * @height
    self.bitmap = Bitmap.new(@width,@height)
    self.bitmap.blt(0,0, @bitmap,Rect.new(@sx, @sy, @width, @height))
    @bitmaps[path] = self.bitmap
    flag = false
    end
    end
    self.bitmap = @bitmaps[path]
    # ”òs
    update_fly
    # ƒVƒFƒCƒN
    update_shake
    # ‰ñ“]
    update_turning
    # ”½“]
    update_reverse
    # ˆÚ“®
    update_moving
    # ’ljÁƒAƒjƒ
    update_add_anime
    # ƒGƒtƒFƒNƒgŒø‰Ê‚Ì“K—p
    update_effect
    # ƒAƒjƒ[ƒVƒ‡ƒ“ ID ‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    flag = RTAB ? true : @battler.damage == nil
    if flag and @battler.state_animation_id != @state_animation_id
    @state_animation_id = @battler.state_animation_id
    loop_animation($data_animations[@state_animation_id])
    end
    # ƒVƒFƒCƒN
    if @battler.shake
    self.start_shake(5, 5, 5)
    @battler.shake = false
    end
    # –¾–Å
    if @battler.blink
    blink_on
    else
    blink_off
    end
    # •s‰ÂŽ‹‚Ìê‡
    unless @battler_visible
    flag = RTAB ? (@battler.damage.size < 2 or @battler.damage_pop.size < 2) :
    (@battler.damage == nil or @battler.damage_pop)
    # oŒ»
    if not @battler.hidden and not @battler.dead? and flag
    appear
    @battler_visible = true
    end
    end
    if RTAB
    # ƒ_ƒ[ƒW
    for battler in @battler.damage_pop
    if battler[0].class == Array
    if battler[0][1] >= 0
    $scene.skill_se
    else
    $scene.levelup_se
    end
    damage(@battler.damage[battler[0]], false, 2)
    else
    damage(@battler.damage[battler[0]], @battler.critical[battler[0]])
    end
    if @battler.damage_sp.include?(battler[0])
    damage(@battler.damage_sp[battler[0]],
    @battler.critical[battler[0]], 1)
    @battler.damage_sp.delete(battler[0])
    end
    @battler.damage_pop.delete(battler[0])
    @battler.damage.delete(battler[0])
    @battler.critical.delete(battler[0])
    end
    end
    # ‰ÂŽ‹‚Ìê‡
    if @battler_visible
    # “¦‘–
    if @battler.hidden
    $game_system.se_play($data_system.escape_se)
    escape
    @battler_visible = false
    end
    # ”’ƒtƒ‰ƒbƒVƒ…
    if @battler.white_flash
    whiten
    @battler.white_flash = false
    end
    if RTAB
    # ƒAƒjƒ[ƒVƒ‡ƒ“
    if !@battler.animation.empty?
    for animation in @battler.animation.reverse
    if animation[2]
    animation($data_animations[animation[0]], animation[1], true)
    else
    animation($data_animations[animation[0]], animation[1])
    end
    @battler.animation.delete(animation)
    end
    end
    else
    # ƒAƒjƒ[ƒVƒ‡ƒ“
    if @battler.animation_id != 0
    animation = $data_animations[@battler.animation_id]
    animation(animation, @battler.animation_hit)
    @battler.animation_id = 0
    end
    end
    # ƒ_ƒ[ƒW
    if !RTAB and @battler.damage_pop
    damage(@battler.damage, @battler.critical)
    @battler.damage = nil
    @battler.critical = false
    @battler.damage_pop = false
    end
    flag = RTAB ? (@battler.damage.empty? and $scene.dead_ok?(@battler)) :
    @battler.damage == nil
    # ƒRƒ‰ƒvƒX
    if flag and @battler.dead?
    if @battler.is_a?(Game_Actor)
    $game_system.se_play($data_system.actor_collapse_se)
    elsif @battler.is_a?(Game_Enemy)
    $game_system.se_play($data_system.enemy_collapse_se)
    end
    collapse
    @battler_visible = false
    end
    end
    # ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
    self.x = @battler.screen_x + @effect_ox
    self.y = @battler.screen_y + @effect_oy
    self.z = @battler.screen_z
    self.zoom_x = @battler.real_zoom
    self.zoom_y = @battler.real_zoom
    # ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðŒ¸‚ç‚·
    @battler.wait_count -= 1
    @battler.wait_count2 -= 1
    # ƒAƒjƒ[ƒVƒ‡ƒ“‘Ò‚¿ŽžŠÔŽæ“¾
    @battler.animation_duration = @_animation_duration
    if @battler.is_a?(Game_Actor)
    self.zoom_x *= CHAR_ZOOM
    self.zoom_y *= CHAR_ZOOM
    end
    # ‰“‹——£ƒAƒjƒ
    if @battler.flying_anime != [0,0,false,false] and @flying.nil?
    @flying = Sprite_Flying.new(self.viewport, @battler)
    elsif @battler.flying_anime == [0,0,false,false] and !@flying.nil?
    @flying.dispose
    @flying = nil
    end
    if @flying != nil
    @flying.battler = @battler
    @flying.update
    end
    if @battler.is_a?(Game_Actor)
    # •ŠíƒAƒjƒ
    if @battler.weapon_anime_type1 and @weapon.nil?
    @weapon = Sprite_Weapon.new(self.viewport, @battler)
    elsif !@battler.weapon_anime_type1 and !@weapon.nil?
    @weapon.dispose
    @weapon = nil
    end
    if @weapon != nil
    @weapon.battler = @battler
    @weapon.update
    @weapon.opacity = self.opacity
    @weapon.x = self.x + BLZ_X[@battler.weapon_anime_type3][@battler.pattern]
    @weapon.y = self.y + BLZ_Y[@battler.weapon_anime_type3][@battler.pattern]
    @weapon.angle = BLZ_ANGLE[@battler.weapon_anime_type3][@battler.pattern]
    if self.mirror
    @weapon.angle += @weapon.angle - 180
    end
    end
    end
    # Žc‘œ
    if @battler.shadow
    if Graphics.frame_count % 2 == 0
    shadow = ::Sprite.new(self.viewport)
    shadow.bitmap = self.bitmap.dup
    shadow.x = self.x
    shadow.y = self.y
    shadow.ox = self.ox
    shadow.oy = self.oy
    shadow.mirror = self.mirror
    shadow.angle = self.angle
    shadow.opacity = 160
    shadow.zoom_x = self.zoom_x
    shadow.zoom_y = self.zoom_y
    if @battler.is_a?(Game_Actor)
    shadow.src_rect.set(@sx, @sy, @width, @height)
    else
    shadow.src_rect.set(0, 0, @width, @height)
    end
    @shadow.push([shadow,duration = 10,@battler.true_x + @effect_ox,@battler.true_y + @effect_oy])
    end
    end
    for s in @shadow
    if !s[0].disposed?
    s[0].update
    s[1] -= 1
    if s[1] < 1
    if s[0].bitmap != nil
    s[0].bitmap.dispose
    end
    s[0].dispose
    else
    s[0].x = @battler.screen_x(s[2])
    s[0].y = @battler.screen_y(s[3])
    end
    else
    s = nil
    end
    end
    @shadow.compact!
    end
    #--------------------------------------------------------------------------
    # œ ƒGƒtƒFƒNƒg‚É‚æ‚éÀ•WŒn‚ÌXV
    #--------------------------------------------------------------------------
    def update_effect
    # Šp“x‚ÌC³
    if @_upside_down
    self.angle = (@_turning + 180) % 360
    else
    self.angle = @_turning
    end
    # X À•W‚ÌC³’l
    @effect_ox = @_shake + @_moving[0]
    # Y À•W‚ÌC³’l
    @effect_oy = -@fly + @_moving[1]
    if @_animation == nil or (RTAB and @_animation.empty?)
    self.effect_clear
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒVƒFƒCƒNXV
    #--------------------------------------------------------------------------
    def update_shake
    if @_shake_duration >= 1 or @_shake != 0
    delta = (@_shake_power * @_shake_speed * @_shake_direction) / 10.0
    if @_shake_duration <= 1 and @_shake * (@_shake + delta) < 0
    @_shake = 0
    else
    @_shake += delta
    end
    if @_shake > @_shake_power * 2
    @_shake_direction = -1
    end
    if @_shake < - @_shake_power * 2
    @_shake_direction = 1
    end
    if @_shake_duration >= 1
    @_shake_duration -= 1
    end
    end
    end
    #--------------------------------------------------------------------------
    # œ ”òsXV
    #--------------------------------------------------------------------------
    def update_fly
    if @rand > 0
    @rand -= 1
    return
    end
    if @battler.fly != 0
    if @fly < @battler.fly / 4
    @fly_direction = 1
    elsif @fly > @battler.fly / 2
    @fly_direction = -1
    end
    @fly += 0.5 * @fly_direction
    end
    end
    #--------------------------------------------------------------------------
    # œ ‰ñ“]XV
    #--------------------------------------------------------------------------
    def update_turning
    if @_turning_duration > 0 or @_turning != 0
    @_turning += @_turning_direction * @_turning_speed / 2.0
    # Žc‚è‰ñ“]”‚ðŒ¸‚ç‚·
    if @_turning_direction == -1
    if @_turning_duration > 0 and @_turning < 0
    @_turning_duration -= 1
    end
    elsif @_turning_direction == 1
    if @_turning_duration > 0 and @_turning >= 360
    @_turning_duration -= 1
    end
    end
    # ˆÈ‰º•â³
    while @_turning < 0
    @_turning += 360
    end
    if @_turning_duration <= 0
    @_turning = 0
    end
    @_turning %= 360
    end
    end
    #--------------------------------------------------------------------------
    # œ ¶‰E”½“]XV
    #--------------------------------------------------------------------------
    def update_reverse
    if @last_reverse != (@_reverse or @battler.reverse)
    self.mirror = (@_reverse or @battler.reverse)
    @last_reverse = (@_reverse or @battler.reverse)
    end
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®XV
    #--------------------------------------------------------------------------
    def update_moving
    @move_distance = (@_move_coordinates[2] - @_move_coordinates[0]).abs +
    (@_move_coordinates[3] - @_move_coordinates[1]).abs
    if @move_distance > 0
    return if @_moving[0] == @_move_coordinates[0] and @_moving[1] == @_move_coordinates[1]
    array = @_move_coordinates
    x = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @_move_duration) / @move_distance.to_f).to_i
    y = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @_move_duration) / @move_distance.to_f).to_i
    @_moving = [x, y]
    if @_move_quick_return and @_move_duration == 0
    @_move_coordinates = [0,0,array[0],array[1]]
    @_move_duration = @move_distance
    end
    @_move_duration -= @_move_speed
    @_move_duration = [@_move_duration, 0].max
    end
    end
    #--------------------------------------------------------------------------
    # œ ’ljÁƒAƒjƒXV (RTABŒÀ’è‹@”\)
    #--------------------------------------------------------------------------
    def update_add_anime
    if RTAB
    # ƒAƒjƒ[ƒVƒ‡ƒ“
    if @_add_anime_id != 0
    animation = $data_animations[@_add_anime_id]
    animation(animation, true)
    @_add_anime_id = 0
    end
    end
    end
    #--------------------------------------------------------------------------
    # œ ƒGƒtƒFƒNƒg‰Šú‰»
    #--------------------------------------------------------------------------
    def effect_clear
    @_effect_ox = 0
    @_effect_oy = 0
    @_shake_power = 0
    @_shake_speed = 0
    @_shake_duration = 0
    @_shake_direction = 1
    @_shake = 0
    @_upside_down = false
    @_reverse = false
    @_turning_direction = 1
    @_turning_speed = 0
    @_turning_duration = 0
    @_turning = 0
    @_move_quick_return = true
    @_move_speed = 0
    @_move_coordinates = [0,0,0,0]
    @_move_jump = false
    @_move_duration = 0
    @_moving = [0,0]
    @_add_anime_id = 0
    end
    #--------------------------------------------------------------------------
    # œ ƒVƒFƒCƒN‚ÌŠJŽn
    # power : ‹­‚³
    # speed : ‘¬‚³
    # duration : ŽžŠÔ
    #--------------------------------------------------------------------------
    def start_shake(power, speed, duration)
    @_shake_power = power
    @_shake_speed = speed
    @_shake_duration = duration
    end
    #--------------------------------------------------------------------------
    # œ ㉺”½“]‚ðŠJŽn
    #--------------------------------------------------------------------------
    def start_upside_down
    @_upside_down = @_upside_down ? false : true
    end
    #--------------------------------------------------------------------------
    # œ ¶‰E”½“]‚ðŠJŽn
    #--------------------------------------------------------------------------
    def start_reverse
    @_reverse = @_reverse ? false : true
    end
    #--------------------------------------------------------------------------
    # œ ‰ñ“]‚ðŠJŽn
    # direction: •ûŒü
    # speed : ‘¬‚³
    # duration : ŽžŠÔ
    #--------------------------------------------------------------------------
    def start_turning(direction, speed, duration)
    @_turning_direction = direction
    @_turning_speed = speed
    @_turning_duration = duration
    @_turning = @_turning_direction == 1 ? 0 : 360
    end
    #--------------------------------------------------------------------------
    # œ ˆÚ“®‚ðŠJŽn
    # quick_return : –ß‚é‚©‚Ç‚¤‚©
    # speed : ‘¬‚³
    # x : X À•W
    # y : Y À•W
    #--------------------------------------------------------------------------
    def start_moving(quick_return, speed, x, y)
    @_move_quick_return = quick_return == 0 ? false : true
    @_move_speed = speed
    @_move_coordinates = [x,y,@_move_coordinates[0],@_move_coordinates[1]]
    distance = (@_move_coordinates[2] - @_move_coordinates[0]).abs +
    (@_move_coordinates[3] - @_move_coordinates[1]).abs
    @_move_duration = distance
    end
    #--------------------------------------------------------------------------
    # œ ƒAƒjƒ’ljÁ‚ðŠJŽn
    # id : ID
    # hit : –½’†ƒtƒ‰ƒbƒO
    #--------------------------------------------------------------------------
    def start_add_anime(id)
    @_add_anime_id = id
    end
    #--------------------------------------------------------------------------
    # œ ŠeŽíƒGƒtƒFƒNƒg‚ÌŠJŽn”»’è
    #--------------------------------------------------------------------------
    if !method_defined?("side_view_animation_process_timing")
    alias side_view_animation_process_timing animation_process_timing
    end
    def animation_process_timing(timing, hit)
    side_view_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 =~ SHAKE_FILE
    names = timing.se.name.split(/#/)
    power = names[1].nil? ? SHAKE_POWER : names[1].to_i
    speed = names[2].nil? ? SHAKE_SPEED : names[2].to_i
    duration = names[3].nil? ? SHAKE_DURATION : names[3].to_i
    # ƒVƒFƒCƒN‚ðŠJŽn
    self.start_shake(power, speed, duration)
    end
    if timing.se.name == UPSIDE_DOWN_FILE
    # ㉺”½“]‚ðŠJŽn
    self.start_upside_down
    end
    if timing.se.name == REVERSE_FILE
    # ¶‰E”½“]‚ðŠJŽn
    self.start_reverse
    end
    if timing.se.name =~ TURNING_FILE
    names = timing.se.name.split(/#/)
    direction = names[1].nil? ? TURNING_DIRECTION : names[1].to_i
    speed = names[2].nil? ? TURNING_SPEED : names[2].to_i
    duration = names[3].nil? ? TURNING_DURATION : names[3].to_i
    # ‰ñ“]‚ðŠJŽn
    self.start_turning(direction, speed, duration)
    end
    if timing.se.name =~ MOVE_FILE
    names = timing.se.name.split(/#/)
    quick_return= names[1].nil? ? MOVE_RETURN : names[1].to_i
    speed = names[2].nil? ? MOVE_SPEED : names[2].to_i
    x = names[3].nil? ? MOVE_COORDINATES[0] : names[3].to_i
    y = names[3].nil? ? MOVE_COORDINATES[1] : names[4].to_i
    # ˆÚ“®‚ðŠJŽn
    self.start_moving(quick_return, speed, x, y)
    end
    if timing.se.name =~ ADD_ANIME_FILE
    names = timing.se.name.split(/#/)
    id = names[1].nil? ? ADD_ANIME_ID : names[1].to_i
    # ƒAƒjƒ’ljÁ‚ðŠJŽn
    self.start_add_anime(id)
    end
    end
    end


    end
    #==============================================================================
    # ¡ Sprite_Weapon
    #------------------------------------------------------------------------------
    # @ƒoƒgƒ‰[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µA
    # ƒXƒvƒ‰ƒCƒg‚Ìó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·B
    #==============================================================================


    class Sprite_Weapon < ::Sprite
    include Side_view
    #--------------------------------------------------------------------------
    # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
    #--------------------------------------------------------------------------
    attr_accessor :battler # ƒoƒgƒ‰[
    attr_reader :cw # ƒOƒ‰ƒtƒBƒbƒN‚Ì•
    attr_reader :ch # ƒOƒ‰ƒtƒBƒbƒN‚Ì‚‚³
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    # viewport : ƒrƒ…[ƒ|[ƒg
    # battler : ƒoƒgƒ‰[ (Game_Battler)
    #--------------------------------------------------------------------------
    def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    end
    #--------------------------------------------------------------------------
    # œ ‰ð•ú
    #--------------------------------------------------------------------------
    def dispose
    if self.bitmap != nil
    self.bitmap.dispose
    end
    super
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚Ìê‡
    if @battler == nil or !@battler.is_a?(Game_Actor)
    self.bitmap = nil
    return
    end
    # ƒEƒGƒ|ƒ“ƒAƒjƒ‚̃f[ƒ^Žæ“¾
    @weapon_anime_type = @battler.weapon_anime_type
    # ݒ肪u”ñ•\Ž¦v‚Ìê‡
    if !@weapon_anime_type[1] or @weapon_anime_type[0].nil?
    self.visible = false
    return
    else
    self.visible = true
    end
    # ƒtƒ@ƒCƒ‹–¼‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    if @weapon_anime_type[0] != @weapon_name
    @weapon_name = @weapon_anime_type[0]
    # ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
    self.bitmap = RPG::Cache.icon(@weapon_name)
    @width = bitmap.width
    @height = bitmap.height
    @flag = true
    end
    # Œ»ÝƒAƒjƒƒpƒ^[ƒ“‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    if @pattern != @battler.pattern or @flag or @condition != @battler.condition
    @pattern = @battler.pattern
    @condition = @battler.condition
    self.ox = @width
    self.oy = @height
    self.z = battler.screen_z
    self.zoom_x = @battler.real_zoom * CHAR_ZOOM
    self.zoom_y = @battler.real_zoom * CHAR_ZOOM
    self.src_rect.set(0, 0, @width, @height)
    self.opacity = 255
    # ƒoƒgƒ‰[‚æ‚èŽè‘O‚É•\Ž¦
    if @weapon_anime_type[2]
    self.z += 10
    # ƒoƒgƒ‰[‚æ‚艜‚É•\Ž¦
    else
    self.z -= 10
    end
    @flag = false
    end
    end
    end


    #==============================================================================
    # ¡ Sprite_Flying
    #------------------------------------------------------------------------------
    # @ƒoƒgƒ‰[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µA
    # ƒXƒvƒ‰ƒCƒg‚Ìó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·B
    #==============================================================================


    class Sprite_Flying < RPG::Sprite
    include Side_view
    LATE_COUNT = 20
    #--------------------------------------------------------------------------
    # œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
    #--------------------------------------------------------------------------
    attr_accessor :battler # ƒoƒgƒ‰[
    #--------------------------------------------------------------------------
    # œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
    # viewport : ƒrƒ…[ƒ|[ƒg
    # battler : ƒoƒgƒ‰[ (Game_Battler)
    #--------------------------------------------------------------------------
    def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @battler_visible = false
    @later = LATE_COUNT
    end
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    def update
    super
    # ƒoƒgƒ‰[‚ª nil ‚Ìê‡
    if @battler == nil
    self.bitmap = nil
    loop_animation(nil)
    return
    end
    # ‰“‹——£ƒAƒjƒ
    flying_animation = @battler.flying_animation
    flying_start = flying_animation[0]
    flying_end = flying_animation[1]
    # ƒAƒjƒ[ƒVƒ‡ƒ“ ID ‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
    if @anime_id != @battler.flying_anime[0]
    @anime_id = @battler.flying_anime[0]
    @animation = $data_animations[@anime_id]
    end
    # ƒAƒjƒ[ƒVƒ‡ƒ“ ŠJŽn
    if flying_start
    animation(@animation,true)
    elsif flying_end
    # Á‹Ž‚ð’x‚点‚Ä‚Ý‚½‚è‚·‚é
    @later -= 1
    if @later < 0
    animation(nil, true)
    @later = LATE_COUNT
    end
    end
    self.x = @battler.flying_x
    self.y = @battler.flying_y
    self.z = @battler.screen_z + 1000
    end
    end
    module RPG
    class Skill
    #--------------------------------------------------------------------------
    # œ –‚–@‚©‚Ç‚¤‚©‚Ì”»’f
    #--------------------------------------------------------------------------
    def magic?
    if @atk_f == 0
    return true
    else
    return false
    end
    end
    end
    end


    # ƒAƒ[ƒJ[ƒ\ƒ‹‚̈ʒuC³


    class Arrow_Actor < Arrow_Base
    include Side_view
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    alias side_view_update update
    def update
    side_view_update
    # ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
    if self.actor != nil && (self.x != self.actor.screen_x + ARROW_OX or self.y != self.actor.screen_y + ARROW_OY)
    self.x = self.actor.screen_x + ARROW_OX
    self.y = self.actor.screen_y + ARROW_OY
    end
    end
    end
    class Arrow_Enemy < Arrow_Base
    include Side_view
    #--------------------------------------------------------------------------
    # œ ƒtƒŒ[ƒ€XV
    #--------------------------------------------------------------------------
    alias side_view_update update
    def update
    side_view_update
    # ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
    if self.enemy != nil && (self.x != self.enemy.screen_x + ARROW_OX or self.y != self.enemy.screen_y + ARROW_OY)
    self.x = self.enemy.screen_x + ARROW_OX
    self.y = self.enemy.screen_y + ARROW_OY
    end
    end
    end

  • so hier der screen was ihr beachten müsst ist in grün


    http://ceratic-soft.de/service…970cf1f414fb46255e945.png


    hier der screen zum system ingame da sin aber kene add ons also wird nur das battler pic entnommen ^^


    http://ceratic-soft.de/service…e52a38356ebe9c92924e5.png



    wenn irgendein grapghic fehler angezeigt wrd zb so



    hier steht was/Graphics/num. dan schreibt mir ne email an


    BloodRedDevil@hotmail.de