Страница 70 из 143 ПерваяПервая ... 2060686970717280120 ... ПоследняяПоследняя
Показано с 691 по 700 из 1426

Тема: Помощь с скриптами (RGSS)

  1. #691
    Новичок Аватар для Po4ka
    Информация о пользователе
    Регистрация
    03.04.2012
    Адрес
    Новосибирск
    Сообщений
    6
    Репутация: 0 Добавить или отнять репутацию

    По умолчанию

    Tankentai's sideview battle system. В демке, которую скачал, всё работает, вставляю, выдаёт ошибку. скрипт
    PHP код:
    #==============================================================================
    # ■ Sideview
    #------------------------------------------------------------------------------
    #  サイドビューバトラーを管理するクラスです。
    #==============================================================================
    class SideView
      
    #--------------------------------------------------------------------------
      # ● 公開インスタンス変数 
      #--------------------------------------------------------------------------
      
    attr_accessor   :x                    # 画面X座標
      
    attr_accessor   :y                    # 画面Y座標
      
    attr_accessor   :z                    # 画面Z座標
      
    attr_accessor   :h                    # 高さ座標
      
    attr_accessor   :j                    # ジャンプ座標
      
    attr_accessor   :c                    # カーブ座標
      
    attr_accessor   :ox                   # 横原点
      
    attr_accessor   :oy                   # 縦原点
      
    attr_accessor   :oy_adjust            # 縦原点補正
      
    attr_accessor   :angle                # 回転角度
      
    attr_accessor   :zoom_x               # 横の拡大率
      
    attr_accessor   :zoom_y               # 縦の拡大率
      
    attr_accessor   :pattern_w            # セル横位置(矩形内)
      
    attr_accessor   :pattern_h            # セル縦位置(矩形内)
      
    attr_accessor   :sx                   # セル横位置(画像全体)
      
    attr_accessor   :sy                   # セル縦位置(画像全体)
      
    attr_accessor   :pattern_type         # セル更新タイプ
      
    attr_accessor   :pattern_time         # セル更新間隔
      
    attr_accessor   :graphic_name         # バトラー画像ファイル名
      
    attr_accessor   :graphic_file_index   # バトラー画像ファイル名インデックス
      
    attr_accessor   :graphic_index        # バトラー画像インデックス
      
    attr_accessor   :cw                   # セル横矩形
      
    attr_accessor   :ch                   # セル縦矩形
      
    attr_accessor   :shadow_visible       # 影表示
      
    attr_accessor   :weapon_visible       # 武器表示
      
      
    attr_accessor   :wait                 # 次の動作待ち時間
      
    attr_accessor   :weapon_index         # 表示中の武器画像インデックス配列
      
    attr_accessor   :weapon_end           # 武器アニメ終了フラグ
      
    attr_accessor   :force_action         # 強制アクション
      
    attr_accessor   :target_battler       # ターゲットバトラー情報
      
    attr_accessor   :second_targets       # セカンドターゲット情報
      
    attr_accessor   :m_a_targets          # アニメ飛ばしターゲット情報
      
    attr_accessor   :individual_targets   # 個別処理ターゲットバトラー情報
      
    attr_accessor   :effect_data          # エフェクトデータ
      
    attr_accessor   :anime_id             # アニメID配列
      
    attr_accessor   :anime_move_id        # 飛ばしアニメID配列
      
    attr_accessor   :mirror               # 反転フラグ
      
    attr_accessor   :opacity              # 透明度
      
    attr_accessor   :opacity_data         # 透明度操作情報
      
    attr_accessor   :set_damage           # バトルシーンでのダメージ処理
      
    attr_accessor   :m_a_data             # アニメ飛ばし情報
      
    attr_accessor   :m_a_starter          # アニメ飛ばし開始ターゲット情報
      
    attr_accessor   :action_end           # バトルシーンでの行動終了
      
    attr_accessor   :damage_anime_data    # ダメージ戦闘アニメのデータ
      
    attr_accessor   :anime_no_mirror      # 戦闘アニメの反転禁止フラグ
      
    attr_accessor   :anime_horming        # 戦闘アニメのホーミングフラグ
      
    attr_accessor   :anime_camera_zoom    # 戦闘アニメがカメラに合わせて拡大縮小するか
      
    attr_accessor   :anime_plus_z         # 戦闘アニメZ座標補正
      
    attr_accessor   :derivation_skill_id  # スキル派生ID
      
    attr_accessor   :immortal             # 不死身フラグ
      
    attr_accessor   :mirage               # 残像データ
      
    attr_accessor   :balloon_data         # ふきだしデータ
      
    attr_accessor   :timing               # 別バトラーからのタイミングデータ
      
    attr_accessor   :timing_targets       # タイミングデータを渡す別バトラー
      
    attr_accessor   :color_set            # 色調変更データ
      
    attr_accessor   :color                # 色調データ
      
    attr_accessor   :change_up            # 画像変更フラグ
      
    attr_accessor   :hit                  # 被攻撃回数
      
    attr_accessor   :add_state            # 何度も付加ステートの表示を防ぐフラグ
      
    attr_accessor   :counter_id           # カウンター時のスキルID
      
    attr_accessor   :reflection_id        # 魔法反射時のアニメID
      
    attr_accessor   :result_damage        # ターン終了時のHP変動データ
      
    attr_accessor   :active               # 行動権
      
    attr_accessor   :anime_off            # 戦闘アニメ消去
      
    attr_accessor   :command_action       # コマンドアクションフラグ
        
      
    attr_accessor   :base_x               # 初期位置 X座標
      
    attr_accessor   :base_y               # 初期位置 Y座標
      
    attr_accessor   :base_h               # 初期位置 高さ座標
      
    attr_accessor   :max_pattern_w        # セルの横分割数
      
    attr_accessor   :max_pattern_h        # セルの縦分割数
      
      
    attr_reader     :collapse             # コラプスフラグ
      
    attr_reader     :picture              # ピクチャ表示フラグ
      #--------------------------------------------------------------------------
      # ● オブジェクト初期化
      #--------------------------------------------------------------------------
      
    def initialize(battler)
        @
    battler battler
        reset
      end
      
    #--------------------------------------------------------------------------
      # ● 初期化
      #--------------------------------------------------------------------------
      
    def reset
        
    @0
        
    @0
        
    @0
        
    @0
        
    @0
        
    @0
        
    @jump = []
        @
    curve = []
        @
    ox 0
        
    @oy 0
        
    @oy_adjust 0
        
    @z_plus 0
        
    @move_time 0
        
    @angle 0
        
    @angle_time 0
        
    @zoom_x 1
        
    @zoom_y 1
        
    @zoom_time 0
        
    @pattern_w 0
        
    @pattern_h 0
        
    @sx 0
        
    @sy 0
        
    @pattern_type 0
        
    @pattern_time 0
        
    @pattern_rest_time 0
        
    @graphic_name ""
        
    @graphic_file_index ""
        
    @graphic_index 0
        
    @cw 0
        
    @ch 0
        
    @shadow_visible false
        
    @weapon_visible true
        
        
    @wait 0
        
    @weapon_index = []
        @
    weapon_end true
        
    @full_action = []
        @
    action = []
        @
    force_action ""
        
    @target_battler = []
        @
    second_targets = []
        @
    individual_targets = []
        @
    m_a_targets = []
        @
    effect_data = []
        @
    anime_id = []
        @
    anime_move_id = []
        @
    opacity 255
        
    @opacity_data = []
        @
    set_damage false
        
    @m_a_data = []
        @
    m_a_starter = []
        @
    action_end false
        
    @damage_anime_data = []
        @
    anime_no_mirror false
        
    @anime_horming false
        
    @anime_camera_zoom false
        
    @anime_plus_z true
        
    @derivation_skill_id 0
        
    @immortal false
        
    @mirage = []
        @
    play_data = []
        @
    balloon_data = []
        @
    picture false
        
    @timing = []
        @
    timing_targets = []
        @
    color_set = []
        @
    color = []
        @
    change_up false
        
    @non_motion false
        
    @graphics_change false
        
    @hit 0
        
    @add_state = []
        @
    collapse false
        
    @counter_id 0
        
    @reflection_id 0
        
    @result_damage = [0,0]
        @
    active false
        
    @anime_off false
        
    @command_action false
        
        
    @base_x 0
        
    @base_y 0
        
    @base_z 0
        
    @base_h 0
        
    @max_pattern_w 0
        
    @max_pattern_h 0
        
    @pattern_kind 0
        
    @pattern_count 0
        
    @move_time 0
        
    @mirror false
        
    @battler.set_graphic(@pre_change_data[0], @pre_change_data[1], @pre_change_data[2], @pre_change_data[3]) if @pre_change_data != nil
        
    @pre_change_data nil
      end  
      
    #--------------------------------------------------------------------------
      # ● セットアップ
      #--------------------------------------------------------------------------
      
    def setup(bitmap_widthbitmap_heightfirst_action_flag)
        
    reset if first_action_flag
        set_data
        set_base_position 
    if !@graphics_change
        set_graphics
    (bitmap_widthbitmap_height)
        
    set_target
        setup_graphics_change 
    if @graphics_change
        first_battler_anime_set 
    if first_action_flag
      end  
      
    #--------------------------------------------------------------------------
      # ● バトラーデータ取得
      #--------------------------------------------------------------------------
      
    def set_data
        
    return if @battler == nil
        
    if @battler.actor?
          @
    graphic_name = @battler.character_name
          
    @graphic_index = @battler.character_index
        
    else
          @
    graphic_name = @battler.battler_name
          
    @graphic_index 0
        end
        
    @max_pattern_w max_pattern[0]
        @
    max_pattern_h max_pattern[1]
      
    end
      
    #--------------------------------------------------------------------------
      # ● ベース座標をセット data = [X軸, Y軸, H軸]  moment_set…瞬間配置
      #--------------------------------------------------------------------------
      
    def set_base_position(moment_set true)
        
    mirroring_reset
        
    if @battler.actor?
          
    data N03::ACTOR_POSITION[@battler.index].dup
          
    @base_x data[0] * 100 if !@mirror
          
    @base_x = (Graphics.width data[0]) * 100 if @mirror
        
    else
          
    data = [@battler.screen_x, @battler.screen_y0].dup
          
    @base_x data[0] * 100 if !$sv_camera.mirror
          
    @base_x = (Graphics.width data[0]) * 100 if $sv_camera.mirror
        end
        
    @base_y data[1] * 100
        
    @base_h data[2] * 100
        
    @base_z = @y
        
    return if !moment_set
        
    @= @base_x 
        
    @= @base_y
        
    @= @base_z
      end
      
    #--------------------------------------------------------------------------
      # ● グラフィックデータ取得
      #--------------------------------------------------------------------------
      
    def set_graphics(bitmap_widthbitmap_height)
        
    sign = @graphic_name[/^[\!\$]./]
        if 
    sign && sign.include?('$')
          @
    cw bitmap_width / @max_pattern_w
          
    @ch bitmap_height / @max_pattern_h
        elsif 
    @max_pattern_w == && @max_pattern_h == 1
          
    @cw bitmap_width
          
    @ch bitmap_height
        
    else
          @
    cw bitmap_width / (@max_pattern_w 4)
          @
    ch bitmap_height / (@max_pattern_h 2)
        
    end
        
    @ox = @cw 2
        
    @oy = @ch
        
    @sx = (@graphic_index * @max_pattern_w + @pattern_w) * @cw
        
    @sy = (@graphic_index * @max_pattern_h + @pattern_h) * @ch
      end
      
    #--------------------------------------------------------------------------
      # ● ターゲットをセット
      #--------------------------------------------------------------------------
      
    def set_target(target nil)
        @
    target_battler target
        
    @target_battler = [@battler] if target == nil
        
    @second_targets = @target_battler
      end
      
    #--------------------------------------------------------------------------
      # ● 画像変更用のセットアップ
      #--------------------------------------------------------------------------
      
    def setup_graphics_change
        
    @graphics_change false
        
    @sx = (@graphic_index * @max_pattern_w + @pattern_w) * @cw
        
    @sy = (@graphic_index * @max_pattern_h + @pattern_h) * @ch
      end  
      
    #--------------------------------------------------------------------------
      # ● 戦闘開始時の待機アニメ画像データ取得
      #--------------------------------------------------------------------------
      
    def first_battler_anime_set
        loop 
    do
          
    update
          
    break if @action_data[0] == "motion"
          
    break if @action_data[0] == "move" && @action_data[8] != ""
          
    break if @full_action == []
        
    end
        start_action
    (first_action) if @battler.movable?
      
    end
      
    #--------------------------------------------------------------------------
      # ● アクション開始
      #--------------------------------------------------------------------------
      
    def start_action(kind nil)
        return if @
    event_fix && $game_troop.interpreter.running?
        
    # ウェイト中の場合キャンセル
        
    return @wait -= if @wait && kind == nil
        action_setup 
    if kind != nil
        set_action
    (kind)
        @
    action kind if @action == nil
        
    # 行動配列が無い場合は行動終了処理へ移行
        
    action_terminate if @action == nil
        
    # 次のアクション決定
        
    @action_data N03::ACTION[@action]
        
    next_action
      end
      
    #--------------------------------------------------------------------------
      # ● 行動パラメータの初期化
      #--------------------------------------------------------------------------
      
    def action_setup
        
    @event_fix false
        
    @set_damage false
        
    @action_end false
        
    @balloon_data = []
        @
    loop_act = []
        
    angle_reset
        zoom_reset
        opacity_reset
        
    @curve = []
        @
    0
        convert_jump
      end  
      
    #--------------------------------------------------------------------------
      # ● 行動終了処理
      #--------------------------------------------------------------------------
      
    def action_terminate
        
    @mirage = [] if @mirage_end
        mirroring_reset
        
    @picture false
        
    @individual_targets = []
        
    action_setup
        
    # 待機アクションへ移行
        
    stand_by_action if !@non_motion
        
    # 戦闘行動のアクティブ権を終了
        
    next_battler
      end  
      
    #--------------------------------------------------------------------------
      # ● 新しいアクション内容の決定
      #--------------------------------------------------------------------------
      
    def set_action(kind nil)
        
    full_act N03::FULLACTION[kind]
        @
    full_action full_act.dup if full_act != nil
        
    @action = @full_action.shift
        
    # 参照したアクションがフルアクションであれば全体のアクションを統合
        
    full_act2 N03::FULLACTION[@action]
        @
    full_action full_act2.dup + @full_action if full_act2 != nil
      end
      
    #--------------------------------------------------------------------------
      # ● 次のアクションへ
      #--------------------------------------------------------------------------
      
    def next_action
        
    @wait 0
        
    # ショートカット確認
        
    eval(@action) if @action != nil && @action_data == nil && N03::FULLACTION[@action] == nil
        
    # ウエイト設定
        
    @wait = @action.to_i if @wait == && @action_data == nil
        
    @wait rand(@wait.abs 1) if @wait 0
        
    # アクション開始
        
    action_play
      end
      
    #--------------------------------------------------------------------------
      # ● 待機アクションへ移行
      #--------------------------------------------------------------------------
      
    def stand_by_action
        
    # 通常待機に
        
    stand_by_act normal
        
    # HPが1/4でピンチアクションに
        
    stand_by_act pinch if @battler.hp <= @battler.mhp 4
        
    # ステートチェック
        
    stand_by_act state(@battler.states[0].id) if @battler.states[0] != nil && state(@battler.states[0].id) != nil
        
    # コマンドチェック
        
    stand_by_act command if @command_action && command != nil
        set_action
    (stand_by_act)
        @
    action stand_by_act if @action == nil
      end
      
    #--------------------------------------------------------------------------
      # ● 強制アクション開始
      #--------------------------------------------------------------------------
      
    def start_force_action
        
    return if @active
        start_action
    (@force_action)
        @
    force_action ""
      
    end  
      
    #--------------------------------------------------------------------------
      # ● アクション追加
      #--------------------------------------------------------------------------
      
    def add_action(kind)
        @
    full_action.push(kind)
      
    end  
      
    #--------------------------------------------------------------------------
      # ● アクションの挿入
      #--------------------------------------------------------------------------
      
    def unshift_action(kind)
        @
    full_action.unshift(kind)
      
    end  
      
    #--------------------------------------------------------------------------
      # ● フレーム更新
      #--------------------------------------------------------------------------
      
    def update
        
    # アクション開始
        
    start_action
        
    # 強制アクション開始
        
    start_force_action if @force_action != ""
        
    # アニメパターン更新
        
    update_pattern
        
    # 移動更新
        
    update_move
        
    # 回転更新
        
    update_angle if @angle_time != 0
        
    # 拡大縮小更新
        
    update_zoom if @zoom_time != 0
        
    # 透明度更新
        
    update_opacity if @opacity_data != []
      
    end
      
    #--------------------------------------------------------------------------
      # ● アニメパターン更新
      #--------------------------------------------------------------------------
      
    def update_pattern
        
    return @pattern_rest_time -= if @pattern_rest_time != 0
        
    return if @max_pattern_w == && @max_pattern_h == 1
        
    @pattern_rest_time = @pattern_time
        
    # 再生開始・終了セル位置を取得
        
    if @pattern_kind # 通常再生中
          
    @pattern_start 0
          
    @pattern_end = @max_pattern_w 1
        elsif 
    @pattern_kind # 逆転再生中
          
    @pattern_start = @max_pattern_w 1
          
    @pattern_end 0
        end
        
    # 片道の再生が終了
        
    @pattern_count += if @pattern_w == @pattern_end && @pattern_kind != 0
        
    # ループ処理
        
    case @pattern_type.abs
        when  1
    ,# 片道
          
    @pattern_kind =  if @pattern_count != && @pattern_type ==  1
          
    @pattern_kind =  if @pattern_count != && @pattern_type == -1
          
    @pattern_kind =  if @pattern_count != && @pattern_type ==  3
          
    @pattern_kind = -if @pattern_count != && @pattern_type == -3
          
    @pattern_w = @pattern_start - @pattern_kind if @pattern_count != && @pattern_type.abs == 3
          
    @pattern_count 0
        when  2
    ,# 往復
          
    @pattern_kind = -if @pattern_count == && @pattern_type ==  2
          
    @pattern_kind =  if @pattern_count == && @pattern_type == -2
          
    @pattern_kind =  if @pattern_count == && @pattern_type ==  2
          
    @pattern_kind =  if @pattern_count == && @pattern_type == -2
          
    @pattern_kind = -if @pattern_count == && @pattern_type ==  4
          
    @pattern_kind =  if @pattern_count == && @pattern_type == -4
          
    @pattern_kind =  if @pattern_count == && @pattern_type ==  4
          
    @pattern_kind = -if @pattern_count == && @pattern_type == -4
          
    @pattern_count if @pattern_count == 2
        end
        
    # セル更新
        
    @pattern_w += * @pattern_kind
        
    @sx = (@graphic_index * @max_pattern_w + @pattern_w) * @cw
      end
      
    #--------------------------------------------------------------------------
      # ● 移動の更新
      #--------------------------------------------------------------------------
      
    def update_move
        
    @= @100 + @z_plus
        
    return if @move_time == 0
        target_position_set 
    if @horming_move
        
    @= (@* (@move_time 1) + @target_x) / @move_time
        
    @= (@* (@move_time 1) + @target_y) / @move_time
        
    @= (@* (@move_time 1) + @target_h) / @move_time if @move_h != nil
        
    @+= @curve[@move_time 1] if @curve[@move_time 1] != nil
        
    @+= @jump[@move_time 1] if @jump[@move_time 1] != nil
        
    @move_time -= 1
        convert_jump 
    if @move_time == 0
      end
      
    #--------------------------------------------------------------------------
      # ● 移動目標の更新
      #--------------------------------------------------------------------------
      
    def target_position_set
        target_position 
    N03.get_targets_position(@move_targets, @horming_move)
        @
    target_x target_position[0] + @move_x
        
    @target_y target_position[1] + @move_y
        
    @target_h target_position[2] + @move_h if @move_h != nil
      end  
      
    #--------------------------------------------------------------------------
      # ● 回転更新
      #--------------------------------------------------------------------------
      
    def update_angle
        
    @angle += @angling
        
    @angle_time -= 1
        
    return if @angle_time != 0
        
    return angle_reset if @angle_data[4] == 0
        angling
    (@angle_data) if @angle_data[4] == 2
      end  
      
    #--------------------------------------------------------------------------
      # ● 拡大縮小更新
      #--------------------------------------------------------------------------
      
    def update_zoom
        
    @zoom_x += @zooming_x
        
    @zoom_y += @zooming_y
        
    @zoom_time -= 1
        
    return if @zoom_time != 0
        
    return zoom_reset if @zoom_data[4] == 0
        zooming
    (@zoom_data) if @zoom_data[4] == 2
      end
      
    #--------------------------------------------------------------------------
      # ● 透明度更新
      #--------------------------------------------------------------------------
      
    def update_opacity
        
    @opacity += @opacity_data[2]
        @
    opacity_data[0] -= 1
        
    return if @opacity_data[0] != 0
        
    return if !@opacity_data[5]
        @
    opacity_data[2] *= -1
        
    @opacity_data[0] = @opacity_data[1]
      
    end
      
    #--------------------------------------------------------------------------
      # ● アクション実行
      #--------------------------------------------------------------------------
      
    def action_play 
        
    return if @action_data == nil
        action 
    = @action_data[0]
        
    # バトラー反転の場合
        
    return mirroring                    if action == "mirror"
        
    # 残像の場合
        
    return mirage_set                   if action == "mirage"
        
    # 回転の場合  
        
    return angling                      if action == "angle"
        
    # 拡大縮小の場合  
        
    return zooming                      if action == "zoom"
        
    # 透明度操作の場合  
        
    return set_opacity                  if action == "opacity"
        
    # バトラーアニメの場合
        
    return battler_anime                if action == "motion"
        
    # 移動の場合
        
    return move                         if action == "move"
        
    # 武器アニメの場合
        
    return weapon_anime([@action_data]) if action == "wp"
        
    # アニメ飛ばしの場合
        
    return move_anime                   if action == "m_a"
        
    # 戦闘シーン通信の場合(コラプス)
        
    return set_play_data                if action == "collapse" or action == "no_collapse"
        
    # データベース戦闘アニメ表示の場合  
        
    return battle_anime                 if action == "anime"
        
    # カメラワークの場合
        
    return camera                       if action == "camera"
        
    # 画面のシェイクの場合
        
    return shake                        if action == "shake"
        
    # 画面色調変更の場合
        
    return color_effect                 if action == "color"
        
    # トランジションの場合
        
    return transition                   if action == "ts"
        
    # ふきだしアニメ表示の場合  
        
    return balloon_anime                if action == "balloon"
        
    # ピクチャ表示の場合
        
    return picture_set                  if action == "pic"
        
    # ステート操作の場合
        
    return state_set                    if action == "sta"
        
    # FPS変更の場合
        
    return fps                          if action == "fps"
        
    # バトラー画像変更の場合  
        
    return graphics_change              if action == "change"
        
    # スキル派生の場合  
        
    return derivating_skill             if action == "der"
        
    # BGM/BGS/SE演奏の場合  
        
    return sound                        if action == "sound"
        
    # ムービー再生の場合  
        
    return movie                        if action == "movie"
        
    # ゲームスイッチ操作の場合  
        
    return switches                     if action == "switch"
        
    # ゲーム変数操作の場合  
        
    return variable                     if action == "variable"
        
    # 条件分岐(ゲームスイッチ)の場合
        
    return nece_1                       if action == "n_1"
        
    # 条件分岐(ゲーム変数)の場合
        
    return nece_2                       if action == "n_2"
        
    # 条件分岐(ステート)の場合
        
    return nece_3                       if action == "n_3"
        
    # 条件分岐(スキル)の場合
        
    return nece_4                       if action == "n_4"
        
    # 条件分岐(パラメータ)の場合
        
    return nece_5                       if action == "n_5"
        
    # 条件分岐(装備)の場合
        
    return nece_6                       if action == "n_6"
        
    # 条件分岐(スクリプト)の場合
        
    return nece_7                       if action == "n_7"
        
    # セカンドターゲット操作の場合  
        
    return second_targets_set           if action == "s_t"
        
    # コモンイベント呼び出しの場合  
        
    return call_common_event            if action == "common"
        
    # 戦闘アニメ消去の場合  
        
    return @anime_off true            if action == "anime_off"
        
    # 強制戦闘終了の場合  
        
    return BattleManager.process_abort  if action == "battle_end"
        
    # 画面固定の場合  
        
    return Graphics.freeze              if action == "graphics_freeze"
        
    # ダメージアニメの場合  
        
    return damage_anime                 if action == "damage_anime"
        
    # 武器消去の場合  
        
    return @weapon_visible false      if action == "weapon_off"
        
    # 武器消去解除の場合  
        
    return @weapon_visible true       if action == "weapon_on"
        
    # 待機キャンセルの場合
        
    return @non_motion true           if action == "non_motion"
        
    # 待機キャンセル解除の場合
        
    return @non_motion false          if action == "non_motion_cancel"
        
    # 初期位置変更の場合
        
    return change_base_position         if action == "change_base_position"
        
    # 初期位置変更解除の場合
        
    return set_base_position(false)     if action == "set_base_position"
        
    # 強制アクションの場合  
        
    return force_act                    if action == "force_action"
        
    # 強制アクションの場合 (セカンドターゲット)
        
    return force_act2                   if action == "force_action2"
        
    # 個別開始の場合
        
    return individual_start             if action == "individual_start"
        
    # 個別終了の場合
        
    return individual_end               if action == "individual_end"
        
    # ループ開始の場合
        
    return loop_start                   if action == "loop_start"
        
    # ループ終了の場合
        
    return loop_end                     if action == "loop_end"
        
    # 自分のみ更新の場合
        
    return only_action_on               if action == "only_action_on"
        
    # 自分のみ更新解除の場合
        
    return only_action_off              if action == "only_action_off"
        
    # 次の行動者へ移行の場合
        
    return next_battler                 if action == "next_battler"
        
    # 画像変更フラグの場合
        
    return set_change                   if action == "set_change"
        
    # スクリプト操作の場合   
        
    return eval(@action_data[0])
      
    end
      
    #--------------------------------------------------------------------------
      # ● バトラー反転実行
      #--------------------------------------------------------------------------
      
    def mirroring
        
    @mirror = !@mirror
      end  
      
    #--------------------------------------------------------------------------
      # ● 反転初期化
      #--------------------------------------------------------------------------
      
    def mirroring_reset
        
    @mirror false
        mirroring 
    if !@battler.actor? && N03::ENEMY_MIRROR
        mirroring 
    if $sv_camera.mirror
      end  
      
    #--------------------------------------------------------------------------
      # ● 残像実行
      #--------------------------------------------------------------------------
      
    def mirage_set
        
    @mirage = @action_data.dup
        
    @mirage_end = @mirage[3]
        @
    mirage = [] if @mirage[1] == 0
      end  
      
    #--------------------------------------------------------------------------
      # ● 回転実行
      #--------------------------------------------------------------------------
      
    def angling(data = @action_data)
        @
    angle_data data.dup
        
    @oy = @ch 2
        
    @oy_adjust = @ch 50
        
    @angle_time data[1]
        
    start_angle data[2] * N03.mirror_num(@mirror)
        
    end_angle data[3] * N03.mirror_num(@mirror)
        
    # 時間が0以下なら即座に最終角度へ
        
    @angle_time if @angle_time <= 0
        
    # 回転時間から1フレームあたりの角度を出す
        
    @angling = (end_angle start_angle) / @angle_time
        
    # 割り切れない余りを初期角度に
        
    @angle = (end_angle start_angle) % @angle_time start_angle
      end 
      
    #--------------------------------------------------------------------------
      # ● 回転初期化
      #--------------------------------------------------------------------------
      
    def angle_reset
        
    @oy = @ch
        
    @angle = @angle_time = @oy_adjust 0
      end  
      
    #--------------------------------------------------------------------------
      # ● 拡大縮小実行
      #--------------------------------------------------------------------------
      
    def zooming(data = @action_data)
        @
    zoom_data data.dup
        
    @zoom_time data[1]
        
    start_zoom_x data[2][0]
        
    start_zoom_y data[2][1]
        
    end_zoom_x data[3][0]
        
    end_zoom_y data[3][1]
        
    # 時間が0以下なら即座に最終サイズへ
        
    @zoom_time if @zoom_time <= 0
        
    # 拡大縮小時間から1フレームあたりの拡大縮小率を出す
        
    @zooming_x = (end_zoom_x start_zoom_x) / @zoom_time
        
    @zooming_y = (end_zoom_y start_zoom_y) / @zoom_time
        
    # 開始サイズに
        
    @zoom_x start_zoom_x
        
    @zoom_y start_zoom_y
      end  
      
    #--------------------------------------------------------------------------
      # ● 拡大縮小初期化
      #--------------------------------------------------------------------------
      
    def zoom_reset
        
    @zoom_x = @zoom_y 1
        
    @zoom_time 0
      end  
      
    #--------------------------------------------------------------------------
      # ● バトラー透明度操作
      #--------------------------------------------------------------------------
      
    def set_opacity
        data 
    = @action_data.dup
        
    @opacity data[2]
        
    opacity_move = (data[3] - data[2])/ data[1]
        @
    opacity_data = [data[1], data[1], opacity_movedata[4], data[5], data[6]]
        @
    wait data[1] if data[7]
        @
    wait *= if data[6] && data[7]
      
    end 
      
    #--------------------------------------------------------------------------
      # ● 透明度操作初期化
      #--------------------------------------------------------------------------
      
    def opacity_reset
        
    @opacity 255
        
    @opacity if @battler.hidden?
        @
    opacity_data = []
      
    end
      
    #--------------------------------------------------------------------------
      # ● バトラーアニメ実行
      #--------------------------------------------------------------------------
      
    def battler_anime(anime_data nil)
        
    anime_data = @action_data.dup if anime_data == nil
        
    @graphic_file_index anime_data[1] if !graphic_fix
        
    @pattern_h anime_data[2]
        @
    pattern_w anime_data[3]
        @
    pattern_h if @max_pattern_w == 1
        
    @pattern_w if @max_pattern_h == 1
        
    @pattern_type anime_data[4]
        @
    pattern_time anime_data[5]
        @
    pattern_rest_time anime_data[5]
        @
    pattern_count 0
        
    @pattern_kind 1
        
    @pattern_kind = -if @pattern_type 0
        
    @pattern_kind if @pattern_type == 0
        
    @sx = (@graphic_index * @max_pattern_w + @pattern_w) * @cw
        
    @sy = (@graphic_index * @max_pattern_h + @pattern_h) * @ch
        
    @z_plus anime_data[6]
        @
    wait set_anime_wait if anime_data[7]
        @
    shadow_visible anime_data[8]
        
    weapon_anime(anime_data)
      
    end
      
    #--------------------------------------------------------------------------
      # ● アニメウエイト計算
      #--------------------------------------------------------------------------
      
    def set_anime_wait
        
    if @pattern_type 0
          pattern_time_a 
    = @max_pattern_w - @pattern_w.abs
        elsif 
    @pattern_type 0
          pattern_time_a 
    = @pattern_w.abs 1
        
    else
          return @
    pattern_time if @pattern_type == 0
        end
        
    case @pattern_type
        when 1
    ,-13,-3
          
    return pattern_time_a * @pattern_time 
        when 2
    ,-24,-4
          
    return pattern_time_a * @pattern_time + (@max_pattern_w 2) * @pattern_time
        end
      end  
      
    #--------------------------------------------------------------------------
      # ● 移動実行
      #--------------------------------------------------------------------------
      
    def move
        
    @move_targets N03.get_targets(@action_data[1].abs, @battler)
        return if @
    move_targets == []
        @
    move_targets = [@battler] if @action_data[1].abs == 7
        
    @move_x = @action_data[2] * 100 N03.mirror_num(@mirror)
        @
    move_y = @action_data[3] * 100
        
    @move_h = @action_data[4] * 100 if @action_data[4] != nil
        
    @move_h nil if @action_data[4] == nil
        battler_anime
    (N03::ACTION[@action_data[8]].dup) if N03::ACTION[@action_data[8]] != nil
        
    @horming_move true
        
    @horming_move false if @action_data[1] < or @action_data[1].abs == 7
        target_position_set
        target_position 
    = [@target_x, @target_y, @target_z]
        
    distanse_move = @action_data[5] > 0
        
    @move_time N03.distanse_calculation(@action_data[5].abstarget_position, [@x, @y, @z], distanse_move)
        @
    wait = @move_time
        curve
        jump
        
    @move_time if @move_time == 0
        
    @horming_move false if !@move_targets or @move_targets.include?(@battler)
        
    update_move if @move_time == 1
      end  
      
    #--------------------------------------------------------------------------
      # ● カーブ実行 
      #--------------------------------------------------------------------------
      
    def curve
        
    @0
        
    return if @action_data[6] == 0
        
    @curve N03.parabola([@action_data[6], -@action_data[6]], @move_time1004)
      
    end  
      
    #--------------------------------------------------------------------------
      # ● ジャンプ実行
      #--------------------------------------------------------------------------
      
    def jump
        convert_jump
        
    return if @action_data[7] == [0,0]
        @
    jump N03.parabola(@action_data[7].dup, @move_time100)
      
    end  
      
    #--------------------------------------------------------------------------
      # ● J座標(ジャンプ高度)をH座標に変換
      #--------------------------------------------------------------------------
      
    def convert_jump
        
    @+= @j
        
    @0
        
    @jump = []
      
    end  
      
    #--------------------------------------------------------------------------
      # ● データベース戦闘アニメ実行
      #--------------------------------------------------------------------------
      
    def battle_anime
        data 
    = @action_data.dup
        targets 
    N03.get_targets(data[2], @battler)
        return if 
    targets == []
        
    data[8] = !data[8] if @mirror
        
    @set_damage           data[5]
        @
    damage_anime_data[0] = N03.get_attack_anime_id(data[1], @battler)
        @
    damage_anime_data[1] = data[8]
        @
    damage_anime_data[2] = data[7]
        @
    damage_anime_data[3] = data[6]
        @
    damage_anime_data[4] = data[9]
        @
    wait N03.get_anime_time(@damage_anime_data[0]) - if data[4]
        return if @
    set_damage
        
    for target in targets do display_anime(targetstargetdataend
      end
      
    #--------------------------------------------------------------------------
      # ● 武器アニメ開始
      #--------------------------------------------------------------------------
      
    def weapon_anime(anime_data)
        @
    weapon_end true
        
    for i in 9...anime_data.size
          set_effect_data
    (anime_data[i]) if anime_data[i] != ""
        
    end
      end
      
    #--------------------------------------------------------------------------
      # ● アニメ飛ばし開始
      #--------------------------------------------------------------------------
      
    def move_anime
        
    @m_a_starter = []
        @
    m_a_targets = []
        
    starters N03.get_targets(@action_data[2], @battler)
        
    targets N03.get_targets(@action_data[3], @battler)
        return if 
    starters == [] or targets == []
        
    single_start true if starters != nil && @action_data[2] < 0
        single_start 
    true if @action_data[1][0] != && $data_animations[N03.get_attack_anime_id(@action_data[1][0], @battler)].position == 3
        starters 
    = [starters[0]] if single_start
        single_end 
    true if targets != nil && @action_data[3] < 0
        single_end 
    true if @action_data[1][1] != && $data_animations[N03.get_attack_anime_id(@action_data[1][1], @battler)].position == 3
        targets 
    = [targets[0]] if single_end
        se_flag 
    true
        
    for starter in starters
          
    for target in targets
            data 
    = @action_data.dup
            data
    [17] = se_flag
            
    @effect_data.push(data)
            @
    m_a_targets.push(target)
            @
    m_a_starter.push(starter)
            
    se_flag false
          end
        end  
      end
      
    #--------------------------------------------------------------------------
      # ● スプライトセット通信
      #--------------------------------------------------------------------------
      
    def set_effect_data(data = @action)
        
    action_data N03::ACTION[data]
        return if 
    action_data == nil
        
    @effect_data.push(action_data.dup)
      
    end
      
    #--------------------------------------------------------------------------
      # ● 戦闘シーン通信のデータを格納
      #--------------------------------------------------------------------------
      
    def set_play_data(data = @action_data)
        @
    play_data data.dup
      end
      
    #--------------------------------------------------------------------------
      # ● 戦闘アニメの表示
      #--------------------------------------------------------------------------
      
    def display_anime(targetstargetdata)
        return if !
    N03.first_of_all_screen_anime(data[1], targettargets)
        
    target.animation_id         N03.get_attack_anime_id(data[1], @battler)
        
    target.animation_mirror     data[8]
        
    target.sv.anime_horming     data[3]
        
    target.sv.anime_camera_zoom data[6]
        
    target.sv.anime_no_mirror   data[7]
        
    target.sv.anime_plus_z      data[9]
      
    end
      
    #--------------------------------------------------------------------------
      # ● 戦闘アニメ拡張データの初期化
      #--------------------------------------------------------------------------
      
    def reset_anime_data
        
    @anime_no_mirror false
        
    @anime_horming false
        
    @anime_camera_zoom false
        
    @timing_targets = []
        @
    anime_plus_z true
      end  
      
    #--------------------------------------------------------------------------
      # ● カメラワーク
      #--------------------------------------------------------------------------
      
    def camera
        data 
    = @action_data.dup
        N03
    .camera(@battlerdata)
        @
    wait data[4] if data[5]
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 画面のシェイク
      #--------------------------------------------------------------------------
      
    def shake
        data 
    = @action_data.dup
        $sv_camera
    .shake(data[1], data[2], data[3])
        @
    wait data[3] if data[4]
      
    end 
      
    #--------------------------------------------------------------------------
      # ● 画面色調変更
      #--------------------------------------------------------------------------
      
    def color_effect
        
    case @action_data[1]
        
    when 0,1,2,3,4,5
          targets 
    N03.get_targets(@action_data[1], @battler)
        
    when 6
          screen 
    true
        when 7
          targets 
    = [@battler] + @target_battler
        when 8
          screen 
    true
          targets 
    $game_troop.members $game_party.battle_members - [@battler]
        
    when 9
          screen 
    true
          targets 
    $game_troop.members $game_party.battle_members - [@battler] - @target_battler
        when 10
          screen 
    true
          targets 
    $game_troop.members $game_party.battle_members
        end
        
    return if screen == nil && targets == []
        for 
    target in targets do target.sv.color_set = @action_data[2end if targets
        
    @wait = @action_data[2][4] if @action_data[3]
        return if !
    screen
        $sv_camera
    .color_set[1] = @action_data[2]
        
    $sv_camera.color_set[2] = @action_data[2]
      
    end  
      
    #--------------------------------------------------------------------------
      # ● トランジション
      #--------------------------------------------------------------------------
      
    def transition
        $sv_camera
    .perform_transition(@action_data)
      
    end  
      
    #--------------------------------------------------------------------------
      # ● ふきだしアニメ表示 
      #--------------------------------------------------------------------------
      
    def balloon_anime
        
    @balloon_data = @action_data.dup
      end  
      
    #--------------------------------------------------------------------------
      # ● ピクチャ表示
      #--------------------------------------------------------------------------
      
    def picture_set
        
    @picture true
        set_effect_data
      end
      
    #--------------------------------------------------------------------------
      # ● ステート操作
      #--------------------------------------------------------------------------
      
    def state_set
        targets 
    N03.get_targets(@action_data[1], @battler)
        return if 
    targets == []
        case @
    action_data[2]
        
    when 1 targets = [targets[rand(targets.size)]]
        
    when 2 targets -= @battler if targets.include?(@battler)
        
    end
        
    for target in targets
          
    for id in @action_data[4]
            
    target.add_state(id) if @action_data[3] == "+"
            
    target.remove_state(id) if @action_data[3] == "-"
          
    end
        end
      end 
      
    #--------------------------------------------------------------------------
      # ● FPS変更
      #--------------------------------------------------------------------------
      
    def fps
        Graphics
    .frame_rate = @action_data[1]
        
    start_action
      end
      
    #--------------------------------------------------------------------------
      # ● バトラー画像変更の場合
      #--------------------------------------------------------------------------
      
    def graphics_change
        
    @graphics_change true
        
    return @battler.graphics_change(@action_data[3]) if !@battler.actor?
        @
    pre_change_data = [@battler.character_name, @battler.character_index, @battler.face_name, @battler.face_index] if @pre_change_data == nil && !@action_data[1]
        if @
    action_data[4] == []
          
    face_name = @battler.face_name
          face_index 
    = @battler.face_index
        
    else
          
    face_name = @action_data[4][1]
          
    face_index = @action_data[4][0]
        
    end
        
    @battler.set_graphic(@action_data[3], @action_data[2], face_nameface_index)
      
    end 
      
    #--------------------------------------------------------------------------
      # ● スキル派生 
      #--------------------------------------------------------------------------
      
    def derivating_skill
        
    # 未修得スキルは派生不可なら
        
    return if !@action_data[1] && !@battler.skill_learn?($data_skills[@action_data[3]])
        
    # コスト不足は派生不可なら
        
    return if !@action_data[2] && !@battler.skill_cost_payable?($data_skills[@action_data[3]])
        
    # 派生
        
    @derivation_skill_id = @action_data[3]
        
    # 以降のアクションをキャンセル
        
    @full_action = []
      
    end
      
    #--------------------------------------------------------------------------
      # ● BGM/BGS/SE演奏
      #--------------------------------------------------------------------------
      
    def sound
        pitch 
    = @action_data[2
        
    vol   = @action_data[3]
        
    name  = @action_data[4
        case @
    action_data[1]
        
    when "se"
          
    Audio.se_play("Audio/SE/" namevolpitch)
        
    when "bgm"
          
    # 名前指定のない場合、現在のBGMを変えないように
          
    name RPG::BGM.last.name if @action_data[4] == ""
          
    Audio.bgm_play("Audio/BGM/" namevolpitch)
        
    when "bgs"
          
    name RPG::BGS.last.name if @action_data[4] == ""
          
    Audio.bgs_play("Audio/BGS/" namevolpitch)
        
    end
      end
      
    #--------------------------------------------------------------------------
      # ● ムービーの再生
      #--------------------------------------------------------------------------
      
    def movie
        Graphics
    .play_movie('Movies/' + @action_data[1])
      
    end
      
    #--------------------------------------------------------------------------
      # ● ゲームスイッチ操作
      #--------------------------------------------------------------------------
      
    def switches
        
    for id in @action_data[1]
          
    $game_switches[id] = true if id 0
          $sv_camera
    .switches[id.abs] = true  if id 0
        end
        
    for id in @action_data[2]
          
    $game_switches[id] = false if id 0
          $sv_camera
    .switches[id.abs] = false  if id 0
        end
        $sv_camera
    .program_check
      end
      
    #--------------------------------------------------------------------------
      # ● ゲーム変数操作
      #--------------------------------------------------------------------------
      
    def variable
        
    # オペランドチェック
        
    operand = @action_data[3]
        
    operand $game_variables[@action_data[3].abs] if @action_data[3] < 0
        
    # 変数操作で分岐
        
    case @action_data[2]
        
    when 0 $game_variables[@action_data[1]] = operand  # 代入
        
    when 1 $game_variables[@action_data[1]] += operand # 加算
        
    when 2 $game_variables[@action_data[1]] -= operand # 減算
        
    when 3 $game_variables[@action_data[1]] *= operand # 乗算
        
    when 4 $game_variables[@action_data[1]] /= operand # 除算
        
    when 5 $game_variables[@action_data[1]] %= operand # 剰余
        
    end
      end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (ゲームスイッチ)
      #--------------------------------------------------------------------------
      
    def nece_1
        judgment 
    $game_switches[@action_data[1]] == @action_data[2] if @action_data[1] > 0
        judgment 
    $sv_camera.switches[@action_data[1].abs] == @action_data[2] if @action_data[1] < 0
        action_diverging
    (judgment, @action_data[3])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (ゲーム変数)
      #--------------------------------------------------------------------------
      
    def nece_2
        variable 
    $game_variables[@action_data[1]]
        
    num = @action_data[2]
        
    num $game_variables[@action_data[2].abs] if num 0
        
    case @action_data[3]
        
    when 0 judgment variable == num
        when 1 
    judgment variable num
        when 2 
    judgment variable num
        end  
        action_diverging
    (judgment, @action_data[4])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (ステート)
      #--------------------------------------------------------------------------
      
    def nece_3
        targets 
    N03.get_targets(@action_data[1], @battler)
        return if 
    targets == []
        
    member_num = @action_data[4]
        
    member_num targets.size if @action_data[4] == && targets.size 1
        hit_count 
    0
        miss_count 
    0
        
    for target in targets
          hit_count 
    += if target.state?(@action_data[2])
          
    miss_count += if !target.state?(@action_data[2])
        
    end
        
    case @action_data[3]
        
    when 0 judgment hit_count >= member_num
        when 1 
    judgment miss_count >= member_num
        end
        action_diverging
    (judgment, @action_data[5])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (スキル)
      #--------------------------------------------------------------------------
      
    def nece_4
        targets 
    N03.get_targets(@action_data[1], @battler)
        return if 
    targets == []
        
    member_num = @action_data[4]
        
    member_num targets.size if @action_data[4] == && targets.size 1
        hit_count 
    0
        miss_count 
    0
        
    for target in targets
          hit_count 
    += if target.skill_learn?($data_skills[@action_data[2]]) && target.skill_conditions_met?($data_skills[@action_data[2]])
          
    miss_count += if !target.skill_learn?($data_skills[@action_data[2]]) or !target.skill_conditions_met?($data_skills[@action_data[2]])
        
    end
        
    case @action_data[3]
        
    when 0 judgment hit_count >= member_num
        when 1 
    judgment miss_count >= member_num
        end
        action_diverging
    (judgment, @action_data[5])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (パラメータ)
      #--------------------------------------------------------------------------
      
    def nece_5
        targets 
    N03.get_targets(@action_data[1], @battler)
        return if 
    targets == []
        
    member_num = @action_data[5]
        
    member_num targets.size if @action_data[5] == && targets.size 1
        hit_count 
    0
        
    for target in targets
          hit_count 
    += if target.comparison_parameter([@action_data[2],@action_data[3],@action_data[4]])
        
    end
        judgment 
    hit_count >= member_num
        action_diverging
    (judgment, @action_data[6])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (装備)
      #--------------------------------------------------------------------------
      
    def nece_6
        targets 
    N03.get_targets(@action_data[1], @battler)
        return if 
    targets == []
        
    member_num = @action_data[5]
        
    member_num targets.size if @action_data[5] == && targets.size 1
        hit_count 
    0
        miss_count 
    0
        
    for target in targets
          hit_count 
    += if target.comparison_equip([@action_data[2],@action_data[3]])
          
    miss_count += if !target.comparison_equip([@action_data[2],@action_data[3]])
        
    end
        
    case @action_data[4]
        
    when 0 judgment hit_count >= member_num
        when 1 
    judgment miss_count >= member_num
        end
        action_diverging
    (judgment, @action_data[6])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● 条件分岐 (スクリプト)
      #--------------------------------------------------------------------------
      
    def nece_7
        judgment 
    = eval(@action_data[2])
        
    action_diverging(judgment, @action_data[1])
      
    end  
      
    #--------------------------------------------------------------------------
      # ● アクション分岐  
      #--------------------------------------------------------------------------
      
    def action_diverging(judgmentkind)
        
    result 0
        
    if judgment
          result 
    if kind == 1
          result 
    if kind == 2
        
    else
          
    result if kind == 0
        end
        
    # フルアクション終了
        
    return @full_action = []  if result == 2
        
    # 次のアクションを除去
        
    @full_action.shift if result == 1
        set_action
        
    # 次のアクションを実行
        
    @action_data N03::ACTION[@action]
        
    next_action
      end
      
    #--------------------------------------------------------------------------
      # ● セカンドターゲット操作
      #--------------------------------------------------------------------------
      
    def second_targets_set
        targets 
    N03.get_targets(@action_data[1], @battler)
        for 
    target in targets
          targets
    .delete(target) if @action_data[2][1] == && target.index != @action_data[2][0]
          
    targets.delete(target) if @action_data[2][1] == && target.index == @action_data[2][0].abs
          targets
    .delete(target) if @action_data[3] > && target.id != @action_data[3]
          
    targets.delete(target) if @action_data[3] < && target.id == @action_data[3].abs
          targets
    .delete(target) if @action_data[4] > && !target.state?(@action_data[4])
          
    targets.delete(target) if @action_data[4] < && target.state?(@action_data[4].abs)
          
    targets.delete(target) if @action_data[5] > && !target.skill_conditions_met?($data_skills[@action_data[5]])
          
    targets.delete(target) if @action_data[5] < && target.skill_conditions_met?($data_skills[@action_data[5].abs])
          
    targets.delete(target) if !target.comparison_parameter(@action_data[6])
          
    targets.delete(target) if !@action_data[7][1].include?(0) && !target.comparison_equip(@action_data[7])
        
    end
        
    return @second_targets = [] if targets.size == 0
        
    case @action_data[8]
        
    when 1 targets = [targets[rand(targets.size)]]
        
    when 2 targets.delete(@battler)
        
    end
        
    return @second_targets = [] if targets.size == 0
        
    @second_targets targets
        
    case @action_data[9]
        
    when 0 ; return
        
    when 1 set_play_data(["second_targets_set"])
        
    when 2 set_play_data(["targets_set"])
        
    end
        
    @wait += 1
      end
      
    #--------------------------------------------------------------------------
      # ● コモンイベント呼び出し
      #--------------------------------------------------------------------------
      
    def call_common_event
        $game_temp
    .reserve_common_event(@action_data[1])
        
    $sv_camera.event true
        
    @event_fix = @action_data[2]
      
    end
      
    #--------------------------------------------------------------------------
      # ● ダメージアニメ
      #--------------------------------------------------------------------------
      
    def damage_anime(delay_time 12)
        
    anime(N03.get_attack_anime_id(-3, @battler), wait true)
        
    action_play
        
    @wait -= delay_time
        
    @full_action.unshift("eval('@damage_anime_data = []
        @set_damage = true')"
    )
      
    end
      
    #--------------------------------------------------------------------------
      # ● 通常コラプス
      #--------------------------------------------------------------------------
      
    def normal_collapse
        
    @collapse true
        
    return
      
    end
      
    #--------------------------------------------------------------------------
      # ● 初期位置変更
      #--------------------------------------------------------------------------
      
    def change_base_position
        
    @base_x = @x
        
    @base_y = @y
        
    @base_h = @h
      end  
      
    #--------------------------------------------------------------------------
      # ● 強制アクション実行
      #--------------------------------------------------------------------------
      
    def force_act
        target
    (@full_action.shift)
      
    end
      
    #--------------------------------------------------------------------------
      # ● 強制アクション実行 (セカンドターゲット)
      #--------------------------------------------------------------------------
      
    def force_act2
        target2
    (@full_action.shift)
      
    end
      
    #--------------------------------------------------------------------------
      # ● 個別処理開始
      #--------------------------------------------------------------------------
      
    def individual_start
        
    @individual_targets = @target_battler.dup
        
    @remain_targets = @target_battler.dup
        
    @target_battler = [@individual_targets[0]]
        
    # リピート部分のアクションを保持
        
    @individual_act = @full_action.dup
      end
      
    #--------------------------------------------------------------------------
      # ● 個別処理終了
      #--------------------------------------------------------------------------
      
    def individual_end
        
    @individual_targets.shift
        
    for target in @individual_targets
          
    @individual_targets.shift if target.dead?
        
    end
        
    # ターゲットが残っているなら行動リピート
        
    return @target_battler = @remain_targets if @individual_targets.size == 0
        
    @full_action = @individual_act.dup
        
    @target_battler = [@individual_targets[0]]
      
    end
      
    #--------------------------------------------------------------------------
      # ● ループ開始
      #--------------------------------------------------------------------------
      
    def loop_start
        
    # ループ部分のアクションを保持
        
    @loop_act = @full_action.dup
      end
      
    #--------------------------------------------------------------------------
      # ● ループ終了
      #--------------------------------------------------------------------------
      
    def loop_end
        
    # 行動リピート
        
    @full_action = @loop_act.dup if @loop_act != []
      
    end
      
    #--------------------------------------------------------------------------
      # ● 次の行動者へ移行
      #--------------------------------------------------------------------------
      
    def next_battler
        
    @action_end true
        
    @active false
      end
      
    #--------------------------------------------------------------------------
      # ● 画像変更フラグ
      #--------------------------------------------------------------------------
      
    def set_change
        
    @change_up true
      end
      
    #--------------------------------------------------------------------------
      # ● 戦闘シーン通信
      #--------------------------------------------------------------------------
      
    def play_data
        data 
    = @play_data
        
    @play_data = []
        return 
    data
      end
      
    #--------------------------------------------------------------------------
      # ● ショートカットコマンド
      #--------------------------------------------------------------------------
      
    def anime(anime_idwait true)
        @
    action_data = ["anime",anime_id,1,false,wait,false,true,false]
      
    end
      def anime_me
    (anime_idwait true)
        @
    action_data = ["anime",anime_id,0,false,wait,false,true,false]
      
    end
      def se
    (filepitch 100)
        @
    action_data = ["sound",  "se"pitch100file]
      
    end
      def target
    (act)
        for 
    target in @target_battler do target.sv.force_action act end
      end
      def target2
    (act)
        for 
    target in @second_targets do target.sv.force_action act end
      end
      def delay
    (time)
        @
    wait = @battler.index time
      end
      
    #--------------------------------------------------------------------------
      # ● バトラーのIDを取得
      #--------------------------------------------------------------------------
      
    def id
        
    return @battler.id if @battler.actor?
        return -@
    battler.id
      end
      
    #--------------------------------------------------------------------------
      # ● 被クリティカルフラグを取得
      #--------------------------------------------------------------------------
      
    def critical?
        return @
    battler.result.critical
      end
      
    #--------------------------------------------------------------------------
      # ● 被回復フラグを取得
      #--------------------------------------------------------------------------
      
    def recovery?
        
    recovery false
        recovery 
    true if @battler.result.hp_damage 0
        recovery 
    true if @battler.result.mp_damage 0
        recovery 
    true if @battler.result.tp_damage 0
        
    return recovery
      end
      
    #--------------------------------------------------------------------------
      # ● 被スキルIDを取得
      #--------------------------------------------------------------------------
      
    def damage_skill_id
        
    return @damage_skill_id
      end
      
    #--------------------------------------------------------------------------
      # ● 被アイテムIDを取得
      #--------------------------------------------------------------------------
      
    def damage_item_id
        
    return @damage_item_id
      end
      
    #--------------------------------------------------------------------------
      # ● 装備武器を取得
      #--------------------------------------------------------------------------
      
    def weapon_id
        
    return if !@battler.weapons[0]
        return @
    battler.weapons[0].id
      end
      
    #--------------------------------------------------------------------------
      # ● 装備武器のタイプを取得
      #--------------------------------------------------------------------------
      
    def weapon_type
        
    return if !@battler.weapons[0]
        return @
    battler.weapons[0].wtype_id
      end
      
    #--------------------------------------------------------------------------
      # ● 盾を装備しているか
      #--------------------------------------------------------------------------
      
    def shield?
        for 
    armor in @battler.armors do return true if armor != nil && armor.etype_id == 1 end
        
    return false
      end
      
    #--------------------------------------------------------------------------
      # ● ダメージがあるか
      #--------------------------------------------------------------------------
      
    def damage_zero?
        return @
    battler.result.hp_damage == && @battler.result.mp_damage == && @battler.result.tp_damage == 0
      end
      
    #--------------------------------------------------------------------------
      # ● スキルIDを取得
      #--------------------------------------------------------------------------
      
    def skill_id
        
    return @counter_id if @counter_id != 0
        
    return if @battler.current_action == nil or @battler.current_action.item == nil
        
    return if @battler.current_action.item.is_a?(RPG::Item)
        return @
    battler.current_action.item.id
      end
      
    #--------------------------------------------------------------------------
      # ● スキルのタイプを取得
      #--------------------------------------------------------------------------
      
    def skill_type
        
    return if skill_id == 0
        
    return $data_skills[skill_id].stype_id
      end
      
    #--------------------------------------------------------------------------
      # ● スキル名を取得
      #--------------------------------------------------------------------------
      
    def skill_name
        
    return "" if skill_id == 0
        
    return $data_skills[skill_id].name
      end
      
    #--------------------------------------------------------------------------
      # ● アイテムIDを取得
      #--------------------------------------------------------------------------
      
    def item_id
        
    return if @battler.current_action == nil or @battler.current_action.item == nil
        
    return @battler.current_action.item.id
      end
      
    #--------------------------------------------------------------------------
      # ● 攻撃アクション
      #--------------------------------------------------------------------------
      
    def attack_action(item)
        return 
    skill_action if item.is_a?(RPG::Skill)
        return 
    item_action
      end
      
    #--------------------------------------------------------------------------
      # ● ダメージアクションベース
      #--------------------------------------------------------------------------
      
    def damage_action_base(item)
        @
    damage_skill_id 0
        
    @damage_item_id 0
        
    @damage_skill_id item.id if item.is_a?(RPG::Skill)
        @
    damage_item_id item.id if item.is_a?(RPG::Item)
      
    end  
      
    #--------------------------------------------------------------------------
      # ● ダメージアクション 
      #--------------------------------------------------------------------------
      
    def damage_action(attackeritem)
        
    damage_action_base(item)
        
    act damage(attacker)
        return if @
    active
        start_action
    (act) if act != nil
      end
      
    #--------------------------------------------------------------------------
      # ● 回避アクション
      #--------------------------------------------------------------------------
      
    def evasion_action(attackeritem)
        
    damage_action_base(item)
        
    act evasion(attacker)
        return if @
    active
        start_action
    (act) if act != nil
      end
      
    #--------------------------------------------------------------------------
      # ● ミスアクション
      #--------------------------------------------------------------------------
      
    def miss_action(attackeritem)
        
    damage_action_base(item)
        
    act miss(attacker)
        return if @
    active
        start_action
    (act) if act != nil
      end
      
    #--------------------------------------------------------------------------
      # ● 閃きスクリプト併用処理
      #--------------------------------------------------------------------------
      
    def flash_action
        
    return "閃き"
      
    end
      
    end

     
    #==============================================================================
    # ■ module N03
    #------------------------------------------------------------------------------
    #  サイドビューバトルのモジュールです。
    #==============================================================================
    module N03
      
    #--------------------------------------------------------------------------
      # ● バトラーの敵グループを取得
      #--------------------------------------------------------------------------
      
    def self.get_enemy_unit(battler)
        return 
    $game_troop if battler.actor?
        return 
    $game_party
      end
      
    #--------------------------------------------------------------------------
      # ● バトラーの味方グループを取得
      #--------------------------------------------------------------------------
      
    def self.get_party_unit(battler)
        return 
    $game_party if battler.actor?
        return 
    $game_troop
      end
      
    #--------------------------------------------------------------------------
      # ● 戦闘アニメ時間の取得
      #--------------------------------------------------------------------------
      
    def self.get_anime_time(anime_id)
        return 
    if anime_id <= 0
        
    return $data_animations[anime_id].frame_max 4
      end
      
    #--------------------------------------------------------------------------
      # ● 攻撃アニメの取得
      #--------------------------------------------------------------------------
      
    def self.get_attack_anime_id(kindbattler)
        return 
    $data_skills[battler.sv.counter_id].animation_id if kind == -&& battler.sv.counter_id != 0
        
    case kind
        when 
    -anime_id battler.atk_animation_id1
        when 
    -anime_id battler.atk_animation_id2
        when 
    -3
          
    if battler.current_action != nil
            anime_id 
    battler.current_action.item.animation_id if battler.current_action.item != nil
          end
        
    else    ; anime_id kind
        end
        
    case anime_id
        when 
    -anime_id battler.atk_animation_id1
        when 
    -anime_id battler.atk_animation_id2
        end
        
    return anime_id if anime_id
        
    return 0
      end  
      
    #--------------------------------------------------------------------------
      # ● 戦闘アニメデータをセット
      #--------------------------------------------------------------------------
      
    def self.set_damage_anime_data(targetstargetdata)
        return if !
    first_of_all_screen_anime(data[0], targettargets)
        
    target.animation_id         data[0]
        
    target.animation_mirror     data[1]
        
    target.sv.anime_no_mirror   data[2]
        
    target.sv.anime_camera_zoom data[3]
        
    target.sv.anime_plus_z      data[4]
      
    end    
      
    #--------------------------------------------------------------------------
      # ● ターゲットの取得 
      #--------------------------------------------------------------------------
      
    def self.get_targets(kindbattler)
        case 
    kind.abs
        when 0 
    ; return [battler].dup
        when 1 
    ; return battler.sv.target_battler.dup
        when 2 
    ; return get_enemy_unit(battler).members.dup
        when 3 
    ; return get_party_unit(battler).members.dup
        when 4 
    ; return $game_troop.members.dup $game_party.battle_members.dup
        when 5 
    ; return battler.sv.second_targets.dup
        end
      end  
      
    #--------------------------------------------------------------------------
      # ● ターゲットの座標を取得
      #--------------------------------------------------------------------------
      
    def self.get_targets_position(targetshormingm_a nil)
        return [
    0,0,0] if targets == nil && !$sv_camera.mirror
        
    return [Graphics.width,0,0] if targets == nil && $sv_camera.mirror
        x 
    0
        
    for i in 0...targets.size
          x 
    += targets[i].sv.base_x if !horming
          y 
    += targets[i].sv.base_y if !horming
          h 
    += targets[i].sv.base_h if !horming
          x 
    += targets[i].sv.if horming
          y 
    += targets[i].sv.if horming
          h 
    += targets[i].sv.if horming
          y 
    -= targets[i].sv.ch 100 if m_a == 0
          y 
    -= targets[i].sv.ch 50 if m_a == 1
        end
        
    return [targets.sizetargets.sizetargets.size]
      
    end
      
    #--------------------------------------------------------------------------
      # ● 速度を時間に変換
      #--------------------------------------------------------------------------
      
    def self.distanse_calculation(timetarget_positionself_positiondistanse_move)
        return 
    time if !distanse_move
        distanse_x 
    self_position[0] - target_position[0]
        
    distanse_x target_position[0] - self_position[0] if target_position[0] > self_position[0]
        
    distanse_y self_position[1] - target_position[1]
        
    distanse_y target_position[1] - self_position[1] if target_position[1] > self_position[1]
        if 
    self_position[2] != nil && target_position[2] != nil
          distanse_h 
    self_position[2] - target_position[2]
          
    distanse_h target_position[2] - self_position[2] if target_position[2] > self_position[2]
        else
          
    distanse_h 0
        end
        distanse 
    = [distanse_xdistanse_ydistanse_h].max
        
    return distanse / (time 100) + 1
      end
      
    #--------------------------------------------------------------------------
      # ● 放物線移動計算
      #--------------------------------------------------------------------------
      
    def self.parabola(datatimesizetype 1)
        
    move_data data
        move_data
    [0] *= size
        move_data
    [1] *= size
        move 
    = []
        
    move_d = []
        for 
    i in 0...time 2
          move
    [i] = move_data[0]
          
    move_d[i] = move_data[1]
          
    move_data[0] = move_data[0] * type / (type)
          
    move_data[1] = move_data[1] * type / (type)
        
    end
        move 
    move move_d.reverse!
        
    move.reverse!
        
    adjust move.inject(0) {|resultitemresult item }
        
    move[move.size 1] += adjust if data[0] == data[1] && adjust != 0
        move
    .unshift(0) if time != 0
        
    return move
      end
      
    #--------------------------------------------------------------------------
      # ● 反転値
      #--------------------------------------------------------------------------
      
    def self.mirror_num(mirror)
        return 
    if !mirror
        
    return -1
      end  
      
    #--------------------------------------------------------------------------
      # ● カメラワーク
      #--------------------------------------------------------------------------
      
    def self.camera(battlerdata)
        
    battler $game_party.battle_members[0] if !battler
        cx 
    data[2][0] * 100
        cy 
    data[2][1] * 100
        
    return $sv_camera.move(cxcydata[3], data[4], true) if data[1] == 6
        targets 
    self.get_targets(data[1], battler)
        return if 
    targets == nil or targets == []
        
    position self.get_targets_position(targetstrue)
        
    $sv_camera.move(position[0], position[1] - position[2], data[3], data[4], false)
      
    end
      
    #--------------------------------------------------------------------------
      # ● コラプス禁止
      #--------------------------------------------------------------------------
      
    def self.immortaling
        
    # 全員に不死身付与
        
    for member in $game_party.battle_members $game_troop.members
          
    # イベント操作等で不死身設定になっていたら解除を無効にするフラグを立てる
          
    member.sv.immortal true if member.state?(N03::IMMORTAL_ID)
          
    member.add_state(N03::IMMORTAL_ID)
        
    end
        
    return true
      end  
      
    #--------------------------------------------------------------------------
      # ● コラプス許可
      #--------------------------------------------------------------------------
      
    def self.unimmortaling
        
    # 全員の不死身化解除(イベント等で不死身設定がされていれば除く)
        
    for member in $game_party.battle_members $game_troop.members
          next 
    if member.dead?
          
    # 不死身ステートが行動中に解除されていた場合、解除無効を解除
          
    member.sv.immortal false if !member.state?(N03::IMMORTAL_ID) && member.sv.immortal
          next member
    .sv.immortal false if member.sv.immortal
          member
    .remove_state(N03::IMMORTAL_ID)
          
    next if member.hp != 0
          member
    .add_state(1)
          
    member.perform_collapse_effect
          member
    .sv.action_terminate
        end
        
    return false
      end  
      
    #--------------------------------------------------------------------------
      # ● スキル派生
      #--------------------------------------------------------------------------
      
    def self.derived_skill(battler)
        
    battler.force_action(battler.sv.derivation_skill_id, -2)
        
    BattleManager.unshift_action_battlers(battler)
      
    end
      
    #--------------------------------------------------------------------------
      # ● ダメージの作成
      #--------------------------------------------------------------------------
      
    def self.set_damage(battlerhp_damagemp_damage)
        
    battler.result.hp_damage hp_damage
        battler
    .result.mp_damage mp_damage
      end
      
    #--------------------------------------------------------------------------
      # ● ターゲット生死確認
      #--------------------------------------------------------------------------
      
    def self.targets_alive?(targets)
        return 
    false if targets == []
        for 
    target in targets do return true if !target.deadend
        
    return false
      end
      
    #--------------------------------------------------------------------------
      # ● ターゲットをセカンドターゲットへ
      #--------------------------------------------------------------------------
      
    def self.s_targets(battler)
        
    battler.sv.target_battler battler.sv.second_targets
        
    return battler.sv.second_targets
      end  
      
    #--------------------------------------------------------------------------
      # ● セカンドターゲットをターゲットへ
      #--------------------------------------------------------------------------
      
    def self.targets_set(battler)
        
    battler.sv.second_targets battler.current_action.make_targets.compact
        battler
    .sv.target_battler battler.sv.second_targets
      end  
      
    #--------------------------------------------------------------------------
      # ● 戦闘アニメ実行判定 (対象:画面時は最初のターゲットのみアニメ実行)
      #--------------------------------------------------------------------------
      
    def self.first_of_all_screen_anime(anime_idtargettargets)
        
    anime $data_animations[anime_id]
        return 
    false if !anime
        
    return true if anime.position != 3
        
    return false if anime.position == && target != targets[0]
        
    targets.delete(target)
        
    target.sv.timing_targets targets
        
    return true
      end
      
    #--------------------------------------------------------------------------
      # ● 戦闘不能付加攻撃か
      #--------------------------------------------------------------------------
      
    def self.dead_attack?(battleritem)
        for 
    state in battler.atk_states
          
    return true if state == battler.death_state_id
        end
        
    for effect in item.effects
          
    return true if effect.code == 21 && effect.data_id == battler.death_state_id
        end
        
    return false
      end  
       
    end 

  2. #692
    Маститый Аватар для The Joker
    Информация о пользователе
    Регистрация
    16.06.2008
    Сообщений
    1,209
    Записей в дневнике
    11
    Репутация: 29 Добавить или отнять репутацию

    По умолчанию

    так.... а вот теперь скажи мне, переменные задаешь? такентай перед верной работой нужно настроить - несколько переменных отвечают за скорость боевки, ее тип и пр. Это вопрос номер раз. А вопрос номер два - какие скрипты в своем проекте ты используешь помимо такентая?
    Damaged

  3. #693
    Новичок Аватар для Po4ka
    Информация о пользователе
    Регистрация
    03.04.2012
    Адрес
    Новосибирск
    Сообщений
    6
    Репутация: 0 Добавить или отнять репутацию

    По умолчанию

    Цитата Сообщение от The Joker Посмотреть сообщение
    так.... а вот теперь скажи мне, переменные задаешь?
    Нет, А где это можно сделать? Других скриптов пока нет.

  4. #694
    Маститый Аватар для The Joker
    Информация о пользователе
    Регистрация
    16.06.2008
    Сообщений
    1,209
    Записей в дневнике
    11
    Репутация: 29 Добавить или отнять репутацию

    По умолчанию

    Плин... у тебя японский такентай? Просто открой редактор и посмотри, какие переменные и переключатели с именами. Я бы сам тебе сказал, да VXAce конфликует с моим VX, и я его не устанавливаю. Там как минимум три переменных должно использоваться - скорость боевки, тип ожидания, и тип столкновения с врагами.
    Damaged

  5. #695
    Маститый Аватар для Andrew
    Информация о пользователе
    Регистрация
    08.02.2011
    Адрес
    Беларусь, Витебск
    Сообщений
    1,049
    Записей в дневнике
    3
    Репутация: 30 Добавить или отнять репутацию

    По умолчанию

    Вот я сейчас сидел и думал, почему выдаёт false
    PHP код:
    true
    false
    = (== false)or((== true) and (== false))
    print 

    В чём проблема?
    ведь по идее должно быть так: false or (true and true) = false or true = true

    упд:
    нашёл решение. Это всё долбанутость в приоритетах руби.
    !a || a && !b

    ответил я сам себе только через три часа поиска и страшных экскрементов с руби.)
    Последний раз редактировалось Andrew; 08.04.2012 в 13:10.


  6. #696
    Познающий Аватар для mephis
    Информация о пользователе
    Регистрация
    27.01.2011
    Адрес
    Новосибирск
    Сообщений
    330
    Записей в дневнике
    8
    Репутация: 34 Добавить или отнять репутацию

    По умолчанию

    В чём проблема?
    Потому что это руби. На хабре есть об этом: http://habrahabr.ru/post/94566/

    Либо пользуйся аналогичными операторами || &&, но имеющими больший приоритет, нежели оператор =

    Либо ставь скобки вокруг всего выражения.


    upd.: Блин, ты что посты себе лишние набиваешь? Сам спросил и сам ответил.

    Модератор, прибей мой пост, будь добр.
    Последний раз редактировалось mephis; 08.04.2012 в 13:05.

  7. #697
    Маститый Аватар для Doctor Cid
    Информация о пользователе
    Регистрация
    21.06.2010
    Адрес
    Esteria
    Сообщений
    1,494
    Записей в дневнике
    49
    Репутация: 32 Добавить или отнять репутацию

    По умолчанию

    Возникла такая проблема, в битвах после побед над врагам перестало прибавляться золото. Из-за чего такое может быть и как это лечить?
    «Оптимизм — это недостаток информации»

  8. #698

    По умолчанию

    А у меня такая задача! Можно ли сделать, чтобы окно выбора появлялось в облачке текста рядом с героем, а не в отдельном блоке? Притом если герой стоит у левого края карты, то облачко бы появлялось справа, и например если он в самом верху, то оно бы появлялось как-то снизу. Дело в том, что у меня герой высотой в 1\3 часть карты, и нужно, чтобы облачко его не загораживало слишком сильно.
    Я сделал набросок, как я это вижу, ну даже не набросок, а скорее "нашвырок" :



    Правда я здесь переборщил - у меня ещё и курсор сбоку вместо рамки. Может, это уже реально сложно сделать, но если всё таки можно - то тогда зашибательски!

    P/S: В игре используется UMS и Font Editor by Andrew.

  9. #699
    Маститый Аватар для Andrew
    Информация о пользователе
    Регистрация
    08.02.2011
    Адрес
    Беларусь, Витебск
    Сообщений
    1,049
    Записей в дневнике
    3
    Репутация: 30 Добавить или отнять репутацию

    По умолчанию

    Сделать руку вместо рамки проще простого, а вот положение... Я как раз сейчас делаю MesSystem+, там можно сделать подобное(примерно 40% того, что тебе нужно. А если ещё использовать переменные и делать расчёты в эвенте, то и 90%).


  10. #700

    По умолчанию

    С переменными - это значит, высчитывать положение героя на карте при помощи обычных команд, и в зависимости от этого включать нужную команду скрипта? Тогда это я бы смог сделать. Только сам скрипт ещё не сделан?
    И ещё, расскажи тогда, как сделать курсор!

Страница 70 из 143 ПерваяПервая ... 2060686970717280120 ... ПоследняяПоследняя

Информация о теме

Пользователи, просматривающие эту тему

Эту тему просматривают: 1 (пользователей: 0 , гостей: 1)

Метки этой темы

Социальные закладки

Социальные закладки

Ваши права

  • Вы не можете создавать новые темы
  • Вы не можете отвечать в темах
  • Вы не можете прикреплять вложения
  • Вы не можете редактировать свои сообщения
  •