# 設定項目_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
# 普通は特に設定する必要はありません。
class Game_Actor
  CREATE_KS_METHOD = true# minus_state_set  add_state  remove_state  をエリアス用に定義する設定
end
class Game_Enemy
  CREATE_KS_METHOD = true# add_state  remove_state  をエリアス用に定義する設定
end
class Numeric
  # 何もない。と見なすタイルＩＤ。0はタイルセットＢの左上。
  # 1544は、タイルセットＡの壁オートタイルの下にある、黒塗りの１マス下。
  BLANK_TILE_IDS = [0,1544]
end

=begin
任意のオブジェクトクラスに、メモを設定するためのメソッドを定義できます。
設定の一部といえるのでここに書きますが、結構な文章量になるであろう事から
実際には別のセクションにまとめて記述した方が良いでしょう。

例）アクター(RPG::Actor)に、ＩＤに応じたメモを設定するメソッド。
class RPG::Actor
  def get_note(id = @id)# RPG::Actor
    result = Vocab::EmpStr
    case id
    when 1
result = "
<通常攻撃 207>
<選択攻撃 -1 207>
<追加攻撃属性 15 40>
<属性強度 15,40:50>
<対弱点耐性 15,40:80>
<行動毎ステート 255:30>
"
    when 3
result = "
<通常攻撃 372>
<選択攻撃 -1 372>
<被弾毎ステート 256:50>
"
    end
    return result
  end
end
=end

# 設定終了_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/


=begin

★ks_基本スクリプト
最終更新日 2011/01/13
2011/01/13  (Array).or?(target_array) 系の説明と機能が変だったので変更。
2011/01/12  Array･Stringクラスに新メソッド。

□===制作・著作===□
MaidensnowOnline  暴兎
単体では特に機能のないスクリプトなので、著作権表記は必要ありません。

□===配置場所===□
MaidensowOnline 製スクリプトの中で最も上、
可能な限り"▼ 素材"の下、近くに配置してください。

□===説明・使用方法===□
MaidensnowOnlineでよく使用されているメソッドを集めたもの。
ほかのスクリプトの前提になることが多い。

セーブデータをロードした際に、各オブジェクトに対して
新たなインスタンス変数を必要に応じて追加する機能の基礎部分を含みます。

また、あらゆるオブジェクトにメモ(@note)を定義、参照できるようになります。
Game_Actor、Game_Enemyに関しては、それぞれ対応するRPG::Actor、RPG::Enemyの
メモを返すように定義されています。



□===新規定義している主なメソッド===□
Game_Actor
  add_state
  remove_state
  minus_state_set
Game_Enemy
  add_state
  remove_state
(これ以降のメソッドでエリアスするために、空メソッドを新規定義しています。)

String
  clear
(機能的には最低限なので、他で同じ機能がある場合はコメントアウトしてください)



□===利用できる新規メソッド===□

マップ名を取得する
  $game_map.name(map_id)

指定した座標のマップタイルＩＤを取得する
  $game_map.r_dat(x,y,z)  # 座標を round_x(x) round_y(y) で判定する。
  $game_map.m_dat(x,y,z)  # round_ の判定を行わず、軽い。
指定した座標のマップタイルＩＤを取得する。オートタイルなら基本タイルのＩＤを取得。
  $game_map.b_dat(x,y,z)  # 座標を round_x(x) round_y(y) で判定する。
  $game_map.mb_dat(x,y,z)  # round_ の判定を行わず、軽い。

Equips[slot]等と同様の機能を持つが、配列を作成しないので処理が軽い。
  (Game_Actor).equip(slot)
  (Game_Actor).weapon(slot)
  (Game_Actor).armor(slot)

(target_array & self) == judge_array と同様の判定を、新たな配列を生成せずに行う。
ただし、配列内の要素の順番は考慮しない。
  (Array).and?(target_array, judge_array)
(target_array & self).empty? と同様の（略
  (Array).and_empty?(target_array)
  
!(target_array | self) == judge_array と同様の（略
  (Array).or?(target_array, judge_array)
  
配列の中で、"最小値"よりも後で値がnilの位置を返す。
  (Array).first_free_pos(最小値)
上のハッシュ版。他の数値以外のキーは考慮しない。
  (Hash).first_free_key(最小値)

新規クラス Hash_And_Array
  keys values の返り値を使い捨てではなく、記録してある配列によって返す。

が使えます。


また、一時計算用の配列やハッシュを定数で保持するようになっています。
module Vocab  内の記述を読んで、使ってみようと思った方は使ってみてください。
詳しい解説や注意点は、ブログの
http://maidensnow.blog100.fc2.com/blog-entry-11.html
を参照してください。
若干ややこしいですが、毎フレーム配列やハッシュを返すようなメソッドに
組み込む事でかなりの軽量化が可能になるようです。

=end


$imported = {} unless $imported

module Vocab
  PerStr = "%s"
  EmpStr = ""
  EmpAry = []
  EmpHas = {}
  MAXER = []
  MINER = []
  if $TEST
    PerStr.freeze
    EmpStr.freeze
    EmpAry.freeze
    EmpHas.freeze
  end
  def self.maxer
    return MAXER.clear
  end
  def self.miner
    return MINER.clear
  end
  TmpStr = ""
  TmpAry = []
  (5).times do TmpAry << [] end
  TmpHas = []
  (2).times do TmpHas << {} end
  def self.t_ary(i)
    return TmpAry[i].clear
  end
  def self.t_has(i)
    return TmpHas[i].clear
  end
  
  C_Ary = []
  @@e_ary_index = -1
  (20).times do C_Ary << [] end
  C_AryGI = []
  @@e_arygi_index = -1
  (10).times do C_AryGI << [] end
  C_AryEQ = []
  @@e_aryeq_index = -1
  (10).times do C_AryEQ << [] end
  C_Ary2 = []
  @@e_ary2_index = -1
  (5).times do C_Ary2 << [] end
  C_Has = []
  @@c_has_index = -1
  (5).times do C_Has << {} end
  def Vocab.e_ary# 値がしばらく保持される必要があるものに使用する
    @@e_ary_index = (@@e_ary_index + 1) % C_Ary.size
    return C_Ary[@@e_ary_index].clear
  end
  def Vocab.e_arygi# Game_Item クラスの高回転データに使う
    @@e_arygi_index = (@@e_arygi_index + 1) % C_AryGI.size
    return C_AryGI[@@e_arygi_index].clear
  end
  def Vocab.e_aryeq# Game_Actor クラスの高回転な装備データに使う
    @@e_aryeq_index = (@@e_aryeq_index + 1) % C_AryEQ.size
    return C_AryEQ[@@e_aryeq_index].clear
  end
  def Vocab.e_ary2# 未使用
    @@e_ary2_index = (@@e_ary2_index + 1) % C_Ary2.size
    return C_Ary2[@@e_ary2_index].clear
  end
  def Vocab.e_has
    @@c_has_index = (@@c_has_index + 1) % C_Has.size
    return C_Has[@@c_has_index].clear
  end
end


module Kernel
  def note# Kernel
    if @note == nil
      @note = get_note(@id)
    end
    return @note
  end
  def get_note(id = @id)# Kernel
    return Vocab::EmpStr
  end
  def pm(*args)# Kernel
    return unless $TEST
    $scene.message("#{args}")
    p *args if Input::press?(Input::F8) && $scene.is_a?(Scene_Map)
    #p *args
  end
  def pp(*args)# Kernel
    return unless $TEST
    $scene.message("#{args}")
    p *args if Input::press?(Input::F7) && $scene.is_a?(Scene_Map)
    #p *args
  end
  def non_action# Kernel
  end
  def serial_obj# Kernel
    return self
  end
  def serial_id# Kernel
    return self
  end
  def id_to_battler
    return self
  end
  def real_name
    return @real_name if @real_name
    return @name
  end
  def description
    return Vocab::EmpStr if @description == nil
    return @description
  end
  def create_ks_param_cache# Kernel
    @__ks_cache_done = true
    self.note.split(/[\r\n]+/).each { |line|
      judge_note_line(line)
    }
  end
  def judge_note_line(line)# Kernel
  end
  def adjust_save_data# Kernel
  end
end


class NilClass
  def <=>(v)# NilClass
    pp "#{v} が nil と比較された", caller
    return 0 <=> v
  end
  def serial_obj# NilClass
    return nil
  end
  def animation_id# NilClass
    return -1
  end
  def name
    return Vocab::EmpStr
  end
  def battler_to_id
    return 0
  end
  def id_to_battler
    return nil
  end
end


#==============================================================================
# ■ Ks_Value_Applyer
#==============================================================================
class Ks_Value_Applyer
  attr_accessor :value
  attr_accessor :value2
  attr_reader   :target_set
  attr_reader   :ignore_set
  attr_reader   :flags
  def value
    return (100 + @value) / 2 if @flags[:half]
    return @value
  end
  def value2
    return @value2 / 2 if @flags[:half]
    return @value2
  end
  def initialize(value = 100, target_set = [], ignore_set = [], value2 = nil)
    @value = value
    @value2 = value2 if value2
    @target_set = target_set
    @ignore_set = ignore_set
    @flags = {}# Ks_Value_Applyer initialize
  end
  def valid?(judge_set)
    if judge_set
      return false if !@target_set.empty? && (@target_set & judge_set).empty?
      return false if !@ignore_set.empty? && !(@ignore_set & judge_set).empty?
    end
    return true
  end
  PER_STR = /\d+%/
  TA_E_STR = /属性\d+/
  IG_E_STR = /除外\d+/
  FLAGS_STR = {
    /技能無視/=>[:ignore_battler], 
    /とどめ/=>[:need_finish], 
    /命中時/=>[:need_hit], 
    /別目標/=>[:new_target], 
    /無消費/=>[:cost_free], 
    /無条件/=>[:cost_free, :can_use_free], 
    /無判定/=>[:can_use_free], 
  }
  def make_flags(str)
    facts = str.split(",")
    vv = facts.find {|str| str =~ PER_STR}
    vv = 100 unless vv
    va = facts.find {|str| str =~ TA_E_STR}
    vi = facts.find {|str| str =~ IG_E_STR}
    if va
      vva = []
      for i in va.scan(/\d{3}/)
        vva << i.to_i
      end
      va = vva
    else
      va = Vocab::EmpAry
    end
    if vi
      vva = []
        for i in vi.scan(/\d{3}/)
          vva << i.to_i
        end
      vi = vva
    else
      vi = Vocab::EmpAry
    end
    @probability = vv.to_i
    @target_set = va
    @ignore_set = vi
    #dat = Ks_Action_Applyer.new(num[0].to_i, vv.to_i, va, vi)
    facts.each {|str| FLAGS_STR.keys.each {|key|
      next unless str =~ key
      for ket in FLAGS_STR[key]
        if ket.is_a?(Array)
          set_flag(ket[0], ket[1])
        else
          set_flag(ket)
        end
      end
    }}
    #p vv, va, vi, self
  end
  def set_flag(flag, value = true)
    @flags[flag] = value
  end
  def [](flag)
    return @flags[flag]
  end
  def []=(flag, value)
    @flags[flag] = value
  end
  def method_missing(nam, *args)
    return @flags[nam]
  end
  def dup# Ks_Value_Applyer
    n_obj = super
    n_obj.instance_variable_set(:@flags, @flags.dup)
    return n_obj
  end
end

#==============================================================================
# ■ Ks_Action_Applyer
#==============================================================================
class Ks_Action_Applyer < Ks_Value_Applyer
  attr_accessor :skill_id
  attr_accessor :probability
  attr_accessor :element_set
  attr_reader   :ignore_set
  attr_reader   :flags
  attr_accessor :target_set
  def initialize(skill_id, probability = 100, target_set = Vocab::EmpAry, ignore_set = Vocab::EmpAry)
    @skill_id = skill_id
    @probability = probability
    @target_set = target_set
    @ignore_set = ignore_set
    @flags = {}# Ks_Action_Applyer initialize
  end
  def skill
    return $data_skills[@skill_id] if @skill_id > 0
    return nil 
  end
  def valid?(user, judge_set = nil, opponent = nil, obj = nil)
    return false unless rand(100) < @probability
    return false unless super(judge_set)
    last_flags = user.set_applyer_flags(self)
    usable = self.can_use_free || !skill || user.skill_can_use?(skill)
    user.restre_applyer_flags(last_flags)
    return usable
  end
end



#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
  attr_accessor :flags
  def create_default_flag# Game_Temp 新規定義
    @flags[:update_objects] = []
    @flags[:reserved_events] = []
  end
  def dispose_window(window)# Game_Temp 新規定義
    @flags[:update_objects].delete(window)
  end
end



#==============================================================================
# ■ Game_Party
#==============================================================================
class Game_Party
  attr_reader   :actors# パーティメンバーIDの配列
end



#==============================================================================
# ■ Game_Troop
#==============================================================================
class Game_Troop
  def adjust_save_data# Game_Troop
    super
    @flags = {} unless @flags# Game_Troop adjust_save_data
  end
end



#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler
  attr_accessor :luncher
  def adjust_save_data# Game_Battler
    super
    @flags = {} unless @flags.is_a?(Hash)# Game_Battler adjust_save_data
    action.adjust_save_data
  end
  def true_weapon(except_free = false) ; return nil ; end# Game_Battler
  def active_weapon ; return nil ; end# Game_Battler
  def active_weapon_name ; return Vocab::EmpStr ; end# Game_Battler
  def hand_symbol(except_free = false)# Game_Battler
    if @free_hand_exec && !except_free
      return (@off_hand_exec ? 2 : 1) + @free_hand_exec.object_id * 10
    end
    return 2 if @off_hand_exec
    return 1
  end
  def former_action
    result = @action.dup
    result.flags = @action.flags.dup
    return result
  end
  def action_swap(former_action)
    @action = former_action
    @action.battler = self
  end
  def record_hand(obj, reset = true)
    res = [@off_hand_exec, @free_hand_exec]
    start_free_hand_attack?(obj) if reset
    return res
  end
  def luncher
    initialize_luncher
    return @luncher
  end
  def initialize_luncher
  end
end
#==============================================================================
# ■ KS_Extend_Data
#==============================================================================
module KS_Extend_Data
  def create_ks_param_cache# KS_Extend_Battler
    @minus_state_set = [] unless @minus_state_set.is_a?(Array)
    super
  end
end
#==============================================================================
# ■ KS_Extend_Battler
#==============================================================================
module KS_Extend_Battler
  attr_reader   :two_swords_style
  def create_ks_param_cache# KS_Extend_Battler
    @plus_state_set = [] unless @plus_state_set.is_a?(Array)
    @__attack_element_set = [1] unless @__attack_element_set.is_a?(Array)
    @animation_id = 1
    super
  end
  def plus_state_set ; create_ks_param_cache unless @__ks_cache_done
    return @plus_state_set
  end
  def minus_state_set ; create_ks_param_cache unless @__ks_cache_done
    return @minus_state_set
  end
end
#==============================================================================
# ■ RPG::Actor
#==============================================================================
class RPG::Actor
  include KS_Extend_Battler
  include KS_Extend_Data
  def create_ks_param_cache ; super ; end# RPG::Actor
  def hit
    return 95
  end
  def attack_element_set ; create_ks_param_cache unless @__ks_cache_done
    return @__attack_element_set ; end
  def animation_id ; create_ks_param_cache unless @__ks_cache_done
    return @animation_id ; end
end
class RPG::Enemy
  include KS_Extend_Battler
  include KS_Extend_Data
  def create_ks_param_cache ; super ; end# RPG::Enemy
  def animation_id ; create_ks_param_cache unless @__ks_cache_done
    return @animation_id ; end
end
#==============================================================================
# ■ RPG::Class
#==============================================================================
class RPG::Class
  def create_ks_param_cache ; super ; end# RPG::Class
  def note
    if @note == nil
      @note = get_note(@id)
    end
    return @note
  end
  def get_note(id)
    return Vocab::EmpStr
  end
end
#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor
  def note#Game_Actor
    return actor.note
  end
  def battler_to_id# Game_Actor 新規定義
    return id + 1000
  end
  def clone# Game_Actor super
    return Marshal.load(Marshal.dump(self))
  end
  def dup# Game_Actor super
    return Marshal.load(Marshal.dump(self))
  end
  def equip(equip_slot, ignore_legal = false)# Game_Actor 新規定義
    wepmax = two_swords_style ? 2 : 1
    return weapon(equip_slot, ignore_legal) if equip_slot < wepmax
    return armor(equip_slot - 1, ignore_legal)
  end
  WEAPON_VARIABLES = [:@weapon_id, :@armor1_id, :@luncher, :@weapon2_id]
  def weapon(equip_slot, ignore_legal = false)# Game_Actor 新規定義
    equip_slot = equip_slot.abs * -1 if $imported[:real_two_swords_style]
    id = instance_variable_get(WEAPON_VARIABLES[equip_slot])
    id = $data_weapons[id] if id.is_a?(Numeric)
    return id
  end
  Armor_Variables = [:@armor1_id, :@armor2_id, :@armor3_id, :@armor4_id]
  def armor(equip_slot, ignore_legal = false)# Game_Actor 新規定義
    if equip_slot < 4
      id = instance_variable_get(Armor_Variables[equip_slot])
    else
      id = extra_armor_id[equip_slot - 4]
      return nil if !id
    end
    id = $data_armors[id] if id.is_a?(Numeric)
    return id
  end
  def armor_k(kind, ignore_legal = false)# Game_Actor 新規定義
    return armor(KGC::EquipExtension::EQUIP_TYPE.index(kind), ignore_legal)
  end
  def active_weapon# Game_Actor 新規定義
    if @free_hand_exec
      return @luncher if @free_hand_exec == :luncher
      return true_weapon.shift_weapons[@free_hand_exec] if true_weapon && @free_hand_exec.is_a?(Array)
      return nil
    end
    return weapon(-1) if @off_hand_exec
    return weapon(0)
  end
  def active_weapon_name# Game_Actor 新規定義
    return active_weapon.name unless active_weapon == nil
    names = actor.weapon_name
    if names
      return names[0] unless @off_hand_exec
      return names[1 % names.size] if @off_hand_exec
    end
    return Vocab::EmpStr
  end
  def true_weapon(except_free = false)
    return weapon(-2) if !except_free && @free_hand_exec == :luncher
    return weapon(0) unless @off_hand_exec
    return weapon(-1) if @off_hand_exec
    return nil
  end
  def bonus_weapon
    if @free_hand_exec
      return true_weapon.shift_weapons[@free_hand_exec] if true_weapon && @free_hand_exec.is_a?(Array)
      return nil if @free_hand_exec == 0
    end
    return weapons[0] unless @off_hand_exec
    return weapons[1] if @off_hand_exec
    return nil
  end
  def weapons
    result = Vocab.e_ary#
    result.push($data_weapons[@weapon_id])
    result.push($data_weapons[@armor1_id]) if !$imported[:real_two_swords_style] && two_swords_style
    result.push($data_weapons[@weapon2_id]) if @weapon2_id.is_a?(Numeric)
    return result
  end
  def armors# Game_Actor 再定義
    result = Vocab.e_ary#
    result.push($data_armors[@armor1_id]) unless !$imported[:real_two_swords_style] && two_swords_style
    result.push($data_armors[@armor2_id])
    result.push($data_armors[@armor3_id])
    result.push($data_armors[@armor4_id])
    return result
  end
if CREATE_KS_METHOD
  def add_state(state_id)# Game_Actor エリアス用に定義
    super
  end
  def remove_state(state_id)# Game_Actor エリアス用に定義
    super
  end
  def minus_state_set# Game_Actor エリアス用に定義
    super
  end
  remove_const(:CREATE_KS_METHOD)
end# if CREATE_KS_METHOD
end
module KGC
  module EquipExtension
    EQUIP_TYPE = [0, 1, 2, 3] unless defined?(:EQUIP_TYPE)
  end
end
#==============================================================================
# ■ Game_Enemy
#==============================================================================
class Game_Enemy
  def note#Game_Enemy
    return enemy.note
  end
  def battler_to_id# Game_Actor 新規定義
    return @index
  end
  def active_weapon_name
    names = enemy.weapon_name
    if names
      return Vocab::EmpStr if @free_hand_exec
      return names[0] unless @off_hand_exec
      return names[1 % names.size] if @off_hand_exec
    end
    return active_weapon.name
  end
if CREATE_KS_METHOD
  def add_state(state_id)# Game_Enemy エリアス用に定義
    super
  end
  def remove_state(state_id)# Game_Enemy エリアス用に定義
    super
  end
  remove_const(:CREATE_KS_METHOD)
end# if CREATE_KS_METHOD
end
#==============================================================================
# ■ Game_BattleAction
#==============================================================================
class Game_BattleAction
  attr_accessor :flags
  def adjust_save_data# Game_BattleAction
    super
    @flags = {} unless @flags.is_a?(Hash)# Game_BattleAction Game_BattleAction
  end
end



#==============================================================================
# ■ RPG::BaseItem
#==============================================================================
class RPG::BaseItem
  include KS_Extend_Data
  def create_ks_param_cache ; super ; end# RPG::BaseItem
end
#==============================================================================
# ■ RPG::Weapon
#==============================================================================
class RPG::Weapon
  def create_ks_param_cache ; super ; end# RPG::Weapon
  def minus_state_set ; create_ks_param_cache unless @__ks_cache_done
    return @minus_state_set
  end
end
#==============================================================================
# ■ RPG::Armor
#==============================================================================
class RPG::Armor
  def create_ks_param_cache ; super ; end# RPG::Armor
end
#==============================================================================
# ■ RPG::UsableItem
#==============================================================================
class RPG::UsableItem
  def create_ks_param_cache ; super ; end# RPG::Item
end
#==============================================================================
# ■ RPG::Item
#==============================================================================
class RPG::Item
  def create_ks_param_cache ; super ; end# RPG::Item
end
#==============================================================================
# ■ RPG::Skill
#==============================================================================
class RPG::Skill
  def create_ks_param_cache ; super ; end# RPG::Skill
end
#==============================================================================
# ■ RPG::State
#==============================================================================
class RPG::State
  include KS_Extend_Data
  def create_ks_param_cache ; super ; end# RPG::State
end



#==============================================================================
# ■ Game_Screen
#==============================================================================
class Game_Screen
  attr_reader   :tone_target                     # 色調
end



#==============================================================================
# ■ Game_Map
#==============================================================================
class Game_Map
  attr_reader   :map               #元マップデータ
  #--------------------------------------------------------------------------
  # ★ 追加
  #--------------------------------------------------------------------------
  def name(id = @map_id)# Game_Map 新規定義
    map = load_data("Data/MapInfos.rvdata")
    return map[id].name
  end
  def m_dat(x,y,z)# Game_Map 新規定義
    return @map.data[x, y, z]
  end
  def r_dat(x,y,z)# Game_Map 新規定義
    return @map.data[round_x(x), round_y(y), z]
  end
  def b_dat(x,y,z)# Game_Map 新規定義
    return r_dat(x,y,z).base_tile_id
  end
  def mb_dat(x,y,z)# Game_Map 新規定義
    return m_dat(x,y,z).base_tile_id
  end
  
  def xy_h(x, y)  ; return x * 1000 + y ; end
  def rxy_h(x, y) ; return round_x(x) * 1000 + round_y(y) ; end
  def next_xy(x, y, dir, times = 1)
    return [round_x(next_x(x, dir, times)), round_y(next_y(y, dir, times))]
  end
  def next_x(x, dir, times = 1)
    return round_x(x + times * dir.shift_x)
  end
  def next_y(y, dir, times = 1)
    return round_y(y + times * dir.shift_y)
  end
  
  #--------------------------------------------------------------------------
  # ● ループ補正後の X 座標計算
  #--------------------------------------------------------------------------
  def round_x(x)
    if loop_horizontal?
      return x % width
    else
      return x
    end
  end
  #--------------------------------------------------------------------------
  # ● ループ補正後の Y 座標計算
  #--------------------------------------------------------------------------
  def round_y(y)
    if loop_vertical?
      return y % height
    else
      return y
    end
  end
  #--------------------------------------------------------------------------
  # 指定座標から 指定座標2 への x距離を返す
  #--------------------------------------------------------------------------
  def distance_x_from_x(bx, tx)
    w = $game_map.width
    bx = round_x(bx)
    tx = round_x(tx)
    sx = bx - tx
    if $game_map.loop_horizontal? && sx.abs > w >> 1
      sx -= w * (sx <=> 0)
    end
    return sx
  end
  #--------------------------------------------------------------------------
  # 指定座標から 指定座標2 への y距離を返す
  #--------------------------------------------------------------------------
  def distance_y_from_y(by, ty)
    h = $game_map.height
    by = round_y(by)
    ty = round_y(ty)
    sy = by - ty
    if $game_map.loop_vertical? && sy.abs > h >> 1
      sy -= h * (sy <=> 0)
    end
    return sy
  end
  DIST_DIRS = [
    [5,8,2],[4,7,1],[6,9,3], 
  ]
  def direction_to_xy(bx, by, tx, ty)
    # base から見た target の方向を返す
    dist_x = distance_x_from_x(bx, tx)
    dist_y = distance_y_from_y(by, ty)
    return DIST_DIRS[dist_x <=> 0][dist_y <=> 0]
  end
end
#==============================================================================
# ■ Game_Character
#==============================================================================
class Game_Character
  def xy_h  ; return $game_map.xy_h(@x, @y)  ; end
  def rxy_h ; return $game_map.rxy_h(@x, @y) ; end
    
  # 色々な距離算出(算出先でRTPのスクリプトの間違いも修正)
  def next_xy(x, y, dir = direction_8dir, times = 1) ; return $game_map.next_xy(x, y, dir, times) ; end
  def distance_x_from_player ; return $game_map.distance_x_from_x(@x, $game_player.x) ; end
  def distance_y_from_player ; return $game_map.distance_y_from_y(@y, $game_player.y) ; end
  def distance_x_from_target(target)
    if target.is_a?(Numeric)
      target = $game_map.interpreter.get_character(target)
    end
    return $game_map.distance_x_from_x(@x, target.x)
  end
  def distance_y_from_target(target)
    if target.is_a?(Numeric)
      target = $game_map.interpreter.get_character(target)
    end
    return $game_map.distance_y_from_y(@y, target.y)
  end
  def distance_x_from_x(target_x) ; return $game_map.distance_x_from_x(@x, target_x) ; end
  def distance_y_from_y(target_y) ; return $game_map.distance_y_from_y(@y, target_y) ; end
  def direction_to_char(target) ; return $game_map.direction_to_xy(@x, @y, target.x, target.y) ; end
  def direction_to_xy(x, y, distance = nil) ; return $game_map.direction_to_xy(@x, @y, x, y) ; end
end
#==============================================================================
# ■ Game_Event
#==============================================================================
class Game_Event < Game_Character
  def name# Game_Event 新規定義
    return @event.name
  end
end



#==============================================================================
# ■ Window_Item
#==============================================================================
class Window_Item
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height)# Window_Item 再定義
    unless @column_max
      cm = true
      @column_max = 2
      super(x, y, width, height)
      @column_max = 2
    else
      super(x, y, width, height)
    end
    self.index = 0
    if cm
      refresh
    end
  end
end



#==============================================================================
# ■ Scene_Base
#==============================================================================
class Scene_Base
  def update_windows_for_temp
    for window in $game_temp.flags[:update_objects]
      window.update
    end
  end
  def adjust_save_data(include_map)# Scene_Base
    $game_system.adjust_save_data
    $game_message.adjust_save_data
    $game_map.adjust_save_data if include_map
    $game_actors.adjust_save_data
    $game_party.adjust_save_data
    $game_troop.adjust_save_data
    $game_player.adjust_save_data
    $game_map.vehicles.each {|character| character.adjust_save_data}
    $game_map.events.values.each {|character| character.adjust_save_data}
  end
end
if defined?(Scene_Battle) && Scene_Battle.is_a?(Class)
class Scene_Battle# if Scene_Battle.is_a?(Class)
  attr_reader   :action_battlers# Scene_Battle
end
end





class Game_Actor ; def serial_id ; return self.id + 6000 ; end ; end
class Game_Enemy ; def serial_id ; return self.enemy.serial_id ; end ; end
class RPG::State ; def serial_id ; return self.id + 7000 ; end ; end
class RPG::Actor ; def serial_id ; return self.id + 6000 ; end ; end
class RPG::Enemy ; def serial_id ; return self.id + 5000 ; end ; end
class RPG::Actor ; def serial_id ; return self.id + 4000 ; end ; end
class RPG::Armor ; def serial_id ; return self.id + 3000 ; end ; end
class RPG::Weapon; def serial_id ; return self.id + 2000 ; end ; end
class RPG::Item  ; def serial_id ; return self.id + 1000 ; end ; end
class RPG::Skill ; def serial_id ; return self.id ; end ; end
class NilClass ; def serial_id ; return -1 ; end ; end


#==============================================================================
# ■ Numeric
#==============================================================================
class Numeric
  def name# Numeric 新規定義
    return to_s
  end
  def id_to_battler
    return $game_actors[self - 1000] if self > 1000
    return $game_troop.enemies[self]
  end
  def set_bit(bit, value = true)
    if value == true
      return self | (0b1 << bit)
    else
      vv = 0b1 << bit
      return (self | vv) ^ vv
    end
  end
#~ a = 0b0100.set_bit(0)
#~ b = 0b10000.set_bit(3)
#~ c = 0b11.set_bit(0, 0)
#~ p a, b, c
# | でビットをオンにできる
# | 後 ^ でビットをオフにできる
  def serial_obj# Numeric 新規定義
    return nil if self < 0
    case self / 1000
    when 6 ; return $game_actors[self % 1000]
    when 5 ; return $data_enemies[self % 1000]
    when 4 ; return $data_actors[self % 1000]
    when 3 ; return $data_armors[self % 1000]
    when 2 ; return $data_weapons[self % 1000]
    when 1 ; return $data_items[self % 1000]
    else   ; return $data_skills[self % 1000]
    end
  end
  
  def apply_percent(per, ignore_zero = false)
    result = self * 100
    case per <=> 100
    when 1
      perr = per
      while perr > 100
        if perr >= 200
          per = 200
        else
          per = perr % 100 + 100
        end
        case result
        when 5000...10000
          result = 10000 - (10000 - result) * 100 / per
        when 1..5000
          res = result * per / 100
          if res > 5000
            diff = 5000 * 100 / result
            perr -= diff - 100
            result = 5000
            next
          end
          result = res
        else
          return self if ignore_zero
          result += per * 10
        end
        perr -= 100
      end
    when -1
      result = result * per / 100
    end
    return result / 100
  end
  
  HXY = []
  def h_xy# Numeric 新規定義
    result = HXY.clear
    result << self / 1000
    result << self % 1000
    return result
  end
  
  def base_tile_id# Numeric 新規定義
    if self.auto_tile_id?
      id = ((self - 2048) / 48) * 48 + 2048
    else
      id = self
    end
    return id
  end
  def blank_tile_id? ; return BLANK_TILE_IDS.include?(self) ; end
  def auto_tile_id? ; return (2048...8192) === self ; end
  def wall_tile_id? ; return (4352...8192) === self ; end
  def water_tile_id? ; return (2048...2816) === self ; end
  def no_auto_shadow? ; return wall_face_id? || ((1536...1551) === self && self != 1544) ; end
  def wall_top_id?
    return true if self == 1022
    return (wall_tile_id? && ((self - 4352) % 768) / 384 < 1)
  end
  def wall_face_id?
    return (wall_tile_id? && ((self - 4352) % 768) / 384 > 0)
  end
  def water_fall_id?
    return (2240...2816) === self && ((self - 2240) % 96) / 48 > 0
  end
  def shift_x# Numeric 新規定義
    case self
    when 2,8   ; return 0
    when 1,4,7 ; return -1
    when 3,6,9 ; return 1
    end
    return 5
  end
  def shift_y# Numeric 新規定義
    case self
    when 1,2,3 ; return 1
    when 4,6   ; return 0
    when 7,8,9 ; return -1
    end
    return 5
  end
end
#==============================================================================
# ■ Array
#==============================================================================
class Array
  def first_free_pos(minid = 0)# Array 新規定義
    return minid if self.size == 0
    for i in minid..self.size
      return i if self[i].nil?
    end
    return i + 1
  end
  def to_s# Array 新規定義
    result = ""
    result += "["
    for i in 0...self.size
      obj = self[i]
      result += obj.to_s unless i.nil?
      result += "nil" if i.nil?
      result += "," unless i == self.size - 1
    end
    result += "]"
  end
  def rand_in ; return self[rand(self.size)] ; end
  def sum# Array 新規定義
    sum = 0
    for num in self
      sum += num if num.is_a?(Numeric)
    end
    return sum
  end
  
  def or?(target_array, judge_array)
    for i in judge_array
      return false unless target_array.include?(i) || self.include?(i)
    end
    return true
  end
  
  def and?(target_array, judge_array)
    for i in judge_array
      return false unless target_array.include?(i) && self.include?(i)
    end
    return true
  end
  def and_empty?(target_array)
    for i in target_array
      return false if self.include?(i)
    end
    return true
  end
  
  # マップ用
  def xy_h ; return self[0] * 1000 + self[1] ; end
  def rxy_h ; return $game_map.round_x(self[0]) * 1000 + $game_map.round_y(self[1]) ; end
end
#~ a = [1,2,3,4,5,11,22]#,33,44,55,111,222,333,444,555
#~ b = [6,7]#,8,9,0,66,77,88,99,00,666,777,888,999,000
#~ while !a.empty?
#~ t = Time.now
#~ for i in 0...10000
#~   tt = (a & b).empty?
#~ end
#~ p a.size, :a, Time.now - t, tt
#~ t = Time.now
#~ for i in 0...10000
#~   tt = a.and_empty?(b)
#~ end
#~ p a.size, :b, Time.now - t, tt
#~ a.shift
#~ end

#==============================================================================
# ■ Hash
#==============================================================================
class Hash
  def first_free_key(minid = 0)# Hash 新規定義
    return minid if self.size == 0
    for i in minid..self.size
      return i if self[i].nil?
    end
    return i + 1
  end
  def to_s# Hash 新規定義
    result = ""
    result += "{"
    for key in self.keys
      result += "#{key}=>#{self[key]}"
      result += ", " unless self.keys[-1] == key
    end
    result += "}"
    return result
  end
  def jointed_str(suf = "", sc = "･")# Hash 新規定義
    strs = {}
    for i in keys
      if strs[self[i]]
        strs[self[i]] += "#{sc}#{i}"
      else
        strs[self[i]] = i.to_s
      end
    end
    str = ""
    for i in strs.keys.sort{|a,b| b<=>a}
      #next if i == 0
      next unless i.abs > 1#i < -1 || (view && i.abs > 1)
      str += " " unless str.empty?
      str += "#{strs[i]}#{i}#{suf}"
    end
    #p self, str
    return str
  end
end
#==============================================================================
# ■ Hash_And_Array
#==============================================================================
class Hash_And_Array < Hash
  attr_reader   :array
  def initialize(*values)
    @keys = []
    @values = []
    super
    @keys = self.keys
    @values = self.values
  end
  def []=(key,value)
    super
    if @keys.include?(key)
      @values[@keys.index(key)] = value
    else
      @keys << key
      @values << value
    end
  end
  def clear
    @values.clear
    @keys.clear
    return super
  end
  def delete(key)
    return unless super
    @values.delete_at(@keys.index(key))
    @keys.delete(key)
  end
  def keys
    return @keys
  end
  def values
    return @values
  end
end


class String
  def clear# String
    self.replace(Vocab::EmpStr)
  end
end