Beiträge von Yamon1907

    projekt muss eingefroren werden und ich kanns höchstens in 2 jahren weiterführen da ich im moment erst arbeiten tue bzw schule + arbeiten und das sin zu lange zeiten und danach muiss ich zivildienst machen


    das wird auch denke ich das ende der idee sein nunja kann ich nichts machen

    so da hier so gut wie überhaupt nichts los is werdch des jezze uf machen


    wie findet ihr die aus tomb raider bekannte animations figur lara croft alias angelina joulie XD


    ???


    ich find die angelina joulie eigendlich voll toll

    es war ja in english BZW die schrift und die art der schrift war tahoma das system hätte ich auch ändern können aber das währ bissl blöd XD das was ich noch machn wollt war die icons ändern aber es funzt irgendwie net ^^

    Schriftart


    Comic Sans MS


    Sprache in game


    Deutsch


    Skript :::::




    #------------------------------------------------------------------------------
    # Ring_Menu
    #------------------------------------------------------------------------------
    # By: XRXS, Dubealex, and Hypershadow180
    #------------------------------------------------------------------------------
    class Scene_Menu
    #------------------------------------------------------------------------------
    # Initialize
    #------------------------------------------------------------------------------
    def initialize(menu_index = 0)
    @menu_index = menu_index
    $location_text=[]
    $gold_text=[]
    $window_size=[]
    $ring_menu_text=[]
    $chara_select=[]
    @window_opacity=[]
    @chara_select=[]
    @window_position=[]
    $location_text[0]="Comic Sans MS" # Font Type
    $location_text[1]=24 # Font Size
    $location_text[2]=0 # Location Title Color
    $location_text[4]=0 # Map Name Color
    $location_text[3]="Location:" # Text
    $gold_text[0]="Comic Sans MS" # Font Type
    $gold_text[1]=24 # Font Size
    $gold_text[2]=0 # Gold Title Color
    $gold_text[3]=0 # Gold Color
    $gold_text[4]="Gold" # Text
    @window_opacity[0]=255 # Border Opacity
    @window_opacity[1]=130 # Background Opacity
    $window_location_skin="001-Blue01" # Location Windowskin
    $window_gold_skin="001-Blue01" # Gold Windowskin
    @window_position[0]=0 # X Axis Position
    @window_position[1]=0 # Location Y Axis Position
    @window_position[2]=384 # Gold Y Axis Position
    $window_size[0]=160 # Length
    $window_size[1]=96 # Height
    $ring_menu_text[0]="Comic Sans MS" # Font Type
    $ring_menu_text[7]=0 # Font Color
    $ring_menu_text[8]=24 # Font Size
    $ring_menu_text[1]="Items"
    $ring_menu_text[2]="Fähigkeiten"
    $ring_menu_text[3]="Ausrüstung"
    $ring_menu_text[4]="Status"
    $ring_menu_text[5]="speichern"
    $ring_menu_text[6]="Beenden"
    @chara_select[0]=408 # X Axis Position
    @chara_select[1]=0 # Y Axis Position
    $chara_select[0]="Comic Sans MS" # Font Type
    $chara_select[1]=0 # Font Color
    $chara_select[5]=24 # Font Size
    $chara_select[2]=255 # Border Opacity
    $chara_select[3]=130 # Background Opacity
    $chara_select[4]="001-Blue01" # Windowskin
    end
    #------------------------------------------------------------------------------
    # Main
    #------------------------------------------------------------------------------
    def main
    @window_location = Window_Location.new
    @window_location.x = @window_position[0]
    @window_location.y = @window_position[1]
    @window_location.opacity = @window_opacity[0]
    @window_location.back_opacity = @window_opacity[1]
    @window_gold = Window_MenuGold.new
    @window_gold.x = @window_position[0]
    @window_gold.y = @window_position[2]
    @window_gold.opacity = @window_opacity[0]
    @window_gold.back_opacity = @window_opacity[1]
    @spriteset = Spriteset_Map.new
    px = $game_player.screen_x - 15
    py = $game_player.screen_y - 24
    @command_window = Window_RingMenu.new(px,py)
    @command_window.index = @menu_index
    if $game_party.actors.size == 0
    @command_window.disable_item(0)
    @command_window.disable_item(1)
    @command_window.disable_item(2)
    @command_window.disable_item(3)
    end
    @command_window.z = 100
    if $game_system.save_disabled
    @command_window.disable_item(4)
    end
    @status_window = Window_RingMenuStatus.new
    @status_window.x = @chara_select[0]
    @status_window.y = @chara_select[1]
    @status_window.z = 200
    @status_window.opacity=$chara_select[2]
    @status_window.back_opacity=$chara_select[3]
    @status_window.visible = false
    Graphics.transition
    loop do
    Graphics.update
    Input.update
    update
    if $scene != self
    break
    end
    end
    Graphics.freeze
    @spriteset.dispose
    @window_location.dispose
    @window_gold.dispose
    @command_window.dispose
    @status_window.dispose
    end
    #------------------------------------------------------------------------------
    # Update
    #------------------------------------------------------------------------------
    def update
    @window_location.update
    @window_gold.update
    @command_window.update
    @status_window.update
    if @command_window.active
    update_command
    return
    end
    if @status_window.active
    update_status
    return
    end
    end
    #------------------------------------------------------------------------------
    # Update Comman
    #------------------------------------------------------------------------------
    def update_command
    if Input.trigger?(Input::B)
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Map.new
    return
    end
    if Input.trigger?(Input::C)
    if $game_party.actors.size == 0 and @command_window.index < 4
    $game_system.se_play($data_system.buzzer_se)
    return
    end
    case @command_window.index
    when 0
    $game_system.se_play($data_system.decision_se)
    $scene = Scene_Item.new
    when 1
    $game_system.se_play($data_system.decision_se)
    @command_window.active = false
    @status_window.active = true
    @status_window.visible = true
    @status_window.index = 0
    when 2
    $game_system.se_play($data_system.decision_se)
    @command_window.active = false
    @status_window.active = true
    @status_window.visible = true
    @status_window.index = 0
    when 3
    $game_system.se_play($data_system.decision_se)
    @command_window.active = false
    @status_window.active = true
    @status_window.visible = true
    @status_window.index = 0
    when 4
    if $game_system.save_disabled
    $game_system.se_play($data_system.buzzer_se)
    return
    end
    $game_system.se_play($data_system.decision_se)
    $scene = Scene_Save.new
    when 5
    $game_system.se_play($data_system.decision_se)
    $scene = Scene_End.new
    end
    return
    end
    return if @command_window.animation?
    if Input.press?(Input::UP) or Input.press?(Input::LEFT)
    $game_system.se_play($data_system.cursor_se)
    @command_window.setup_move_move(Window_RingMenu::MODE_MOVEL)
    return
    end
    if Input.press?(Input::DOWN) or Input.press?(Input::RIGHT)
    $game_system.se_play($data_system.cursor_se)
    @command_window.setup_move_move(Window_RingMenu::MODE_MOVER)
    return
    end
    end
    #------------------------------------------------------------------------------
    # Update Status
    #------------------------------------------------------------------------------
    def update_status
    if Input.trigger?(Input::B)
    $game_system.se_play($data_system.cancel_se)
    @command_window.active = true
    @status_window.active = false
    @status_window.visible = false
    @status_window.index = -1
    return
    end
    if Input.trigger?(Input::C)
    case @command_window.index
    when 1
    if $game_party.actors[@status_window.index].restriction >= 2
    $game_system.se_play($data_system.buzzer_se)
    return
    end
    $game_system.se_play($data_system.decision_se)
    $scene = Scene_Skill.new(@status_window.index)
    when 2
    $game_system.se_play($data_system.decision_se)
    $scene = Scene_Equip.new(@status_window.index)
    when 3
    $game_system.se_play($data_system.decision_se)
    $scene = Scene_Status.new(@status_window.index)
    end
    return
    end
    end
    end
    #------------------------------------------------------------------------------
    # Window_RingMenu
    #------------------------------------------------------------------------------
    class Window_RingMenu < Window_Base
    STARTUP_FRAMES = 20
    MOVING_FRAMES = 5
    RING_R = 64
    ICON_ITEM = RPG::Cache.icon("034-Item03")
    ICON_SKILL = RPG::Cache.icon("044-Skill01")
    ICON_EQUIP = RPG::Cache.icon("001-Weapon01")
    ICON_STATUS = RPG::Cache.icon("050-Skill07")
    ICON_SAVE = RPG::Cache.icon("038-Item07")
    ICON_EXIT = RPG::Cache.icon("046-Skill03")
    ICON_DISABLE= RPG::Cache.icon("")
    SE_STARTUP = "056-Right02"
    MODE_START = 1
    MODE_WAIT = 2
    MODE_MOVER = 3
    MODE_MOVEL = 4
    attr_accessor :index
    #------------------------------------------------------------------------------
    # Initialize
    #------------------------------------------------------------------------------
    def initialize( center_x, center_y )
    super(0, 0, 640, 480)
    self.contents = Bitmap.new(width-32, height-32)
    self.contents.font.name = $ring_menu_text[0]
    self.contents.font.color = text_color($ring_menu_text[7])
    self.contents.font.size = $ring_menu_text[8]
    self.opacity = 0
    self.back_opacity = 0
    s1 = $ring_menu_text[1]
    s2 = $ring_menu_text[2]
    s3 = $ring_menu_text[3]
    s4 = $ring_menu_text[4]
    s5 = $ring_menu_text[5]
    s6 = $ring_menu_text[6]
    @commands = [ s1, s2, s3, s4, s5, s6 ]
    @item_max = 6
    @index = 0
    @items = [ ICON_ITEM, ICON_SKILL, ICON_EQUIP, ICON_STATUS, ICON_SAVE, ICON_EXIT ]
    @disabled = [ false, false, false, false, false, false ]
    @cx = center_x - 16
    @cy = center_y - 16
    setup_move_start
    refresh
    end
    #------------------------------------------------------------------------------
    # Update
    #------------------------------------------------------------------------------
    def update
    super
    refresh
    end
    #------------------------------------------------------------------------------
    # Refresh
    #------------------------------------------------------------------------------
    def refresh
    self.contents.clear
    case @mode
    when MODE_START
    refresh_start
    when MODE_WAIT
    refresh_wait
    when MODE_MOVER
    refresh_move(1)
    when MODE_MOVEL
    refresh_move(0)
    end
    rect = Rect.new(@cx - 272, @cy + 24, self.contents.width-32, 32)
    self.contents.draw_text(rect, @commands[@index],1)
    end
    #------------------------------------------------------------------------------
    # Refresh Start
    #------------------------------------------------------------------------------
    def refresh_start
    d1 = 2.0 * Math::PI / @item_max
    d2 = 1.0 * Math::PI / STARTUP_FRAMES
    r = RING_R - 1.0 * RING_R * @steps / STARTUP_FRAMES
    for i in 0...@item_max
    j = i - @index
    d = d1 * j + d2 * @steps
    x = @cx + ( r * Math.sin( d ) ).to_i
    y = @cy - ( r * Math.cos( d ) ).to_i
    draw_item(x, y, i)
    end
    @steps -= 1
    if @steps < 1
    @mode = MODE_WAIT
    end
    end
    #------------------------------------------------------------------------------
    # Refresh Wait
    #------------------------------------------------------------------------------
    def refresh_wait
    d = 2.0 * Math::PI / @item_max
    for i in 0...@item_max
    j = i - @index
    x = @cx + ( RING_R * Math.sin( d * j ) ).to_i
    y = @cy - ( RING_R * Math.cos( d * j ) ).to_i
    draw_item(x, y, i)
    end
    end
    #------------------------------------------------------------------------------
    # Refresh Move
    #------------------------------------------------------------------------------
    def refresh_move( mode )
    d1 = 2.0 * Math::PI / @item_max
    d2 = d1 / MOVING_FRAMES
    d2 *= -1 if mode != 0
    for i in 0...@item_max
    j = i - @index
    d = d1 * j + d2 * @steps
    x = @cx + ( RING_R * Math.sin( d ) ).to_i
    y = @cy - ( RING_R * Math.cos( d ) ).to_i
    draw_item(x, y, i)
    end
    @steps -= 1
    if @steps < 1
    @mode = MODE_WAIT
    end
    end
    #------------------------------------------------------------------------------
    # Draw Item
    #------------------------------------------------------------------------------
    def draw_item(x, y, i)
    rect = Rect.new(0, 0, @items[i].width, @items[i].height)
    if @index == i
    self.contents.blt( x, y, @items[i], rect )
    if @disabled[@index]
    self.contents.blt( x, y, ICON_DISABLE, rect )
    end
    else
    self.contents.blt( x, y, @items[i], rect, 128 )
    if @disabled[@index]
    self.contents.blt( x, y, ICON_DISABLE, rect, 128 )
    end
    end
    end
    #------------------------------------------------------------------------------
    # Disable Item
    #------------------------------------------------------------------------------
    def disable_item(index)
    @disabled[index] = true
    end
    #------------------------------------------------------------------------------
    # Setup Move Start
    #------------------------------------------------------------------------------
    def setup_move_start
    @mode = MODE_START
    @steps = STARTUP_FRAMES
    if SE_STARTUP != nil and SE_STARTUP != ""
    Audio.se_play("Audio/SE/" + SE_STARTUP, 80, 100)
    end
    end
    #------------------------------------------------------------------------------
    # Setup Move Move
    #------------------------------------------------------------------------------
    def setup_move_move(mode)
    if mode == MODE_MOVER
    @index -= 1
    @index = @items.size - 1 if @index < 0
    elsif mode == MODE_MOVEL
    @index += 1
    @index = 0 if @index >= @items.size
    else
    return
    end
    @mode = mode
    @steps = MOVING_FRAMES
    end
    #------------------------------------------------------------------------------
    # Animation
    #------------------------------------------------------------------------------
    def animation?
    return @mode != MODE_WAIT
    end
    end
    #------------------------------------------------------------------------------
    # Window_RingMenuStatus
    #------------------------------------------------------------------------------
    class Window_RingMenuStatus < Window_Selectable
    #------------------------------------------------------------------------------
    # Initialize
    #------------------------------------------------------------------------------
    def initialize
    super(204, 64, 232, 352)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.size = $chara_select[5]
    refresh
    self.active = false
    self.index = -1
    end
    #------------------------------------------------------------------------------
    # Refresh
    #------------------------------------------------------------------------------
    def refresh
    self.contents.clear
    self.windowskin = RPG::Cache.windowskin($chara_select[4])
    self.contents.font.name = $chara_select[0]
    self.contents.font.color = text_color($chara_select[1])
    @item_max = $game_party.actors.size
    for i in 0...$game_party.actors.size
    x = 80
    y = 80 * i
    actor = $game_party.actors[i]
    draw_actor_graphic(actor, x - 60, y + 65)
    draw_actor_name(actor, x, y + 2)
    draw_actor_hp(actor, x - 40, y + 26)
    draw_actor_sp(actor, x - 40, y + 50)
    end
    end
    #------------------------------------------------------------------------------
    # Update Cursor Rect
    #------------------------------------------------------------------------------
    def update_cursor_rect
    if @index < 0
    self.cursor_rect.empty
    else
    self.cursor_rect.set(0, @index * 80, self.width - 32, 80)
    end
    end
    end
    #------------------------------------------------------------------------------
    # Game_Map
    #------------------------------------------------------------------------------
    class Game_Map
    #------------------------------------------------------------------------------
    # Name
    #------------------------------------------------------------------------------
    def name
    $map_infos[@map_id]
    end
    end
    #------------------------------------------------------------------------------
    # Scene_Title
    #------------------------------------------------------------------------------
    class Scene_Title
    $map_infos = load_data("Data/MapInfos.rxdata")
    for key in $map_infos.keys
    $map_infos[key] = $map_infos[key].name
    end
    end
    #------------------------------------------------------------------------------
    # Window_Location
    #------------------------------------------------------------------------------
    class Window_Location < Window_Base
    #------------------------------------------------------------------------------
    # Initialize
    #------------------------------------------------------------------------------
    def initialize
    super(0, 0, $window_size[0], $window_size[1])
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $location_text[0]
    self.contents.font.size = $location_text[1]
    refresh
    end
    #------------------------------------------------------------------------------
    # Refresh
    #------------------------------------------------------------------------------
    def refresh
    self.contents.clear
    self.windowskin = RPG::Cache.windowskin($window_location_skin)
    self.contents.font.color = text_color($location_text[2])
    self.contents.draw_text(4, 0, 120, 32, $location_text[3])
    self.contents.font.color = text_color($location_text[4])
    self.contents.draw_text(4, 32, 120, 32, $game_map.name, 2)
    end
    end
    #------------------------------------------------------------------------------
    # Window_MenuGold
    #------------------------------------------------------------------------------
    class Window_MenuGold < Window_Base
    #------------------------------------------------------------------------------
    # Initialize
    #------------------------------------------------------------------------------
    def initialize
    super(0, 0, $window_size[0], $window_size[1])
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $gold_text[0]
    self.contents.font.size = $gold_text[1]
    refresh
    end
    #------------------------------------------------------------------------------
    # Refresh
    #------------------------------------------------------------------------------
    def refresh
    self.contents.clear
    self.windowskin = RPG::Cache.windowskin($window_gold_skin)
    self.contents.font.color = text_color($gold_text[2])
    self.contents.draw_text(4, 0, 120, 32, $gold_text[4])
    self.contents.font.color = text_color($gold_text[3])
    self.contents.draw_text(4, 32, 120, 32, $game_party.gold.to_s, 2)
    end
    end



    Screenshot :::


    <br>[url]http://ceratic-soft.de/service/ceratic-image//./uploads//b332a3fd6aebf0f9f60f4d585313943e.png[/url]

    #--------------------------------------------------------------------------
    # œ ƒ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

    #--------------------------------------------------------------------------
    # ™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

    ich werd das mal ebend kommentieren


    ich finds klasse und du hast mit dem erschiesen von leute mit sinnlosen story ideen recht dan findch eins quuhl


    Das ist schon besser, es fehlen noch viele Teile von Shiros Persönlichkeit. Ihr solltet euch über alle Bereiche Gedanken machen. Was macht euer Held am liebsten in seiner Freizeit? Macht er Sport? Hat er """""""""""eine/n Freund/in?"""""""""


    das habch in noch kenem tutorial gelesen was ich jemals gelesen hab wie ich die geschichte machn würde nun ich glab ich würd dem kerl en kerl als freund bzw beziehung geben den ich bin selbts so XD und man kreiert ja eine story die man sselbst ziemlich leiden kann und vor allem nach dem eigenen geschmack ^^


    nun
    Klasse zusammengesetzt und gutes tutorial ^^ daumen hoch;);)

    ja oki öhm dan geb mir doch mal deine icq nummer dan kann ich dir ein paar dinger geben schreib mir die am besten in ner Privaten nachricht oder add mich XD


    266238150


    dazu habt ihr alle zugriff ihr könnt mich adden XD

    öhm schicke idee aber ich frag mich nur wie man sowas satt haben kann mann hat en mund um zu fragen und wenns en prob darstellt dan schreibt in den regeln rein zu denen dingern


    ********
    Wenn ihr etwas sucht schaut euch all die threads an und wenn nix is dan fragen
    ********


    und solange da nichts is is ma selber schuld man braucht regeln um sich dran halten zu können ^^


    ich kann nach en paar skripts suchen um aber hab ken peil woc die hoch laden soll beziehungsweiße hinschicken soll hasu irgendne email adresse oder icq damit ich dir die senden kann en paar hab ich ja schon ^^

    ich habs ungefähr so gemacht wie du es als letztes erklärt hast aber en bissl anerst


    XP deinstalliet
    englishe version benutzt
    es ging damit die datei meines und des anderen spiels geöffnet
    skripts eingefügt
    graphic datei audio in anderes projekt eingefügt aber ich merk grad das ich des mehr als nur umständlich gemacht hab XD

    hoi hab hier en skript beziehungsweise en game nur mein rpg maker kann es nicht öffnen weil es angeblich ne ältere version ist kann den einer für mich öffnen und des eingefügte battle system skript für mich entwenden ?


    *edit*


    da ich den datenanhang net rein tun kann was mich grad totärgert bitte ich darum einfach hier drin ne naricht zu überlassen oder ihr addet mich in icq ihr müsst nur des skript kopieren und in nem word dokument einfügen das währs schon dan über icq schicken oder ihr macht hier drin en spoiler


    ICQ : 266238150


    E-mail : BloodRedDevil@hotmail.de

    ja danke so hatte ich es vor aber das doofe is ich weiß nicht wo ich den licht efekt her nehmen soll wie du denke ich weißt gibts im xp zwar 3 verschiedene eintragszonen also oben graß straße häuser tape 2 fenster und anderes und taoe drei aber ich find einfach nix wo das lich an is und da frage ich mich ob es nicht ein char xp teil gibt wo nur aus licht is oder en lichtpegel wie man ihn im forgotten e book ansehen kann ^^


    gibts so en licht pegel ?

    hoi liebe leute ^^


    ich hab die links hier schon so eingermassen abgetastet aber nich wirklich besonders gute skripts gefunden hat jemand eventuel einen plan wo ich da welche fnden kann oder habt ihr selbst welche die ihr rein stellen könnt


    brauche


    questbuch
    sehr schönes gutes kampfsystem
    Menü und najo XD

    das spiel ast echt du gemacht
    wow wow wow
    ich finds nach vampires dawn eines der besten games die ich je gezoggt hab XD kompliment;););):)