Class: Miyako::SpriteList

Inherits:
Object show all
Includes:
Enumerable, Animation, Layout, SpriteBase
Defined in:
lib/Miyako/API/sprite_list.rb

Overview

複数スプライト管理(リスト)クラス

複数のスプライトを、の一対一のリストとして持っておく。 値の並びの基準は、名前の並びを配列にしたときのもの(SpriteList#valuesの値)に対応する Enumerableからmixinされたメソッド、Array・Hashクラスで使用されている一部メソッド、 swapなどの独自メソッドを追加している (Enumerableからmixinされたメソッドでは、ブロック引数にの配列として渡される) render、render_toを用意し、一気に描画が可能。 名前は配列として管理している。render時には、名前の順番に描画される。 各要素のレイアウトは関与していない(そこがPartsとの違い) また、このクラスインスタンスのdup、cloneはディープコピー(配列の要素も複写)となっていることに注意。

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Layout

#add_snap_child, #bottom, #bottom!, #broad_rect, #center, #center!, #centering, #centering!, #copy_layout, #delete_snap_child, #get_snap_children, #get_snap_sprite, #h, #include_snap_child?, #init_layout, #layout_dispose, #left, #left!, #middle, #middle!, #move, #move_to, #on_move, #outside_bottom, #outside_bottom!, #outside_left, #outside_left!, #outside_right, #outside_right!, #outside_top, #outside_top!, #pos, #rect, #relative_move_to, #relative_move_to!, #reset_snap, #right, #right!, #segment, #set_layout_size, #set_snap_children, #set_snap_sprite, #snap, #top, #top!, #update_layout, #update_layout_position, #w, #x, #y

Methods included from Animation

[]=, anim_hash, reset, start, stop, update, update_animation

Methods included from SpriteBase

#bitmap, #image_rect, #image_size, #oh, #oh=, #ow, #ow=, #ox, #ox=, #oy, #oy=, #part_rect, #rect, #to_sprite, #to_unit, #update

Constructor Details

#initialize(pairs = nil) ⇒ SpriteList

ハッシュを元にSpriteListを生成する

引数を省略すると空のSpriteListを生成する。 要素がの配列となる配列を引数として渡すこともできる。 (ただし、要素がスプライトのみのときは、 名前を“:s_nnn”(nnn:配列インデックス(3桁))として追加する) ハッシュを引数として渡すと、キーをスプライト名とするSpriteListを生成する。

pairs

生成元のインスタンス

返却値

生成したインスタンス



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/Miyako/API/sprite_list.rb', line 158

def initialize(pairs = nil)
  init_layout
  set_layout_size(1,1)
  @list = []
  if pairs.is_a?(Array)
    pairs.each_with_index{|pair, i|
    if pair.is_a?(Array) || pair.is_a?(ListPair)
      @list << ListPair.new(*pair)
    else
      name = sprintf("s_%03d", i).to_sym
      @list << ListPair.new(name, pair)
    end
  }
  elsif pairs.is_a?(Hash)
    pairs.each{|key, value|
      @list << ListPair.new(key, value)
    }
   end
  @visible = true
end

Instance Attribute Details

#visible ⇒ Object

Returns the value of attribute visible.



139
140
141
 
# File 'lib/Miyako/API/sprite_list.rb', line 139

def visible
  @visible
end

Class Method Details

.[](hash) ⇒ Object

ハッシュを元にSpriteListを生成する

ハッシュのキーをスプライト名にして生成する

hash

生成元のハッシュ

返却値

生成したインスタンス



145
146
147
148
 
# File 'lib/Miyako/API/sprite_list.rb', line 145

def SpriteList.[](hash)
  body = SpriteList.new
  hash.each{|k, v| body.push(k ,v)}
end

Instance Method Details

#&(other) ⇒ Object

引数と自分自身とのANDを取る

方法は積集合と同じ(#*参照)

other

計算をするSpriteList

返却値

変更を加えた自分自身の複製



461
462
463
 
# File 'lib/Miyako/API/sprite_list.rb', line 461

def &(other)
  self * other
end

#*(other) ⇒ Object

引数と自分自身との積集合を取る

otherと自分自身で両方割り付けられた名前のみ登録されたリストを生成する 内容は自分自身の本体を割り当てる

other

計算をするSpriteList

返却値

変更を加えた自分自身の複製



441
442
443
444
445
 
# File 'lib/Miyako/API/sprite_list.rb', line 441

def *(other)
  list = SpriteList.new
  self.to_a.each{|pair| list.add(pair[0], pair[1].dup) if other.has_key?(pair[0])}
  list
end

#+(other) ⇒ Object

引数と自分自身との和集合を取る

otherと自分自身で一方でも割り付けられた名前の本体のみ登録する(方法はpush・addと同じ) 名前がバッティングしたときは引数の本体を優先する

other

計算をするSpriteList

返却値

変更を加えた自分自身の複製



430
431
432
433
434
 
# File 'lib/Miyako/API/sprite_list.rb', line 430

def +(other)
  list = self.dup
  other.to_a.each{|pair| list.add(pair[0], pair[1].dup)}
  list
end

#-(other) ⇒ Object

引数と自分自身との差集合を取る

otherと自分自身で両方割り付けられた名前を取り除いたリストを生成する

other

計算をするSpriteList

返却値

変更を加えた自分自身の複製



451
452
453
454
455
 
# File 'lib/Miyako/API/sprite_list.rb', line 451

def -(other)
  list = SpriteList.new
  self.to_a.each{|pair| list.add(pair[0], pair[1].dup) unless other.has_key?(pair[0])}
  list
end

#<<(pair) ⇒ Object

名前・スプライトの対を登録する

リストに名前・スプライトをリストの後ろに追加する 効果はSpriteList#pushと同じ

pair

名前とスプライトの対。として渡す

返却値

追加した自分自身を渡す



421
422
423
 
# File 'lib/Miyako/API/sprite_list.rb', line 421

def <<(pair)
  self.push(pair)
end

#==(other) ⇒ Object

引数と内容が同じかどうかを確認する

方法は#eql?と同じ(#eql?参照)

other

比較元SpriteList

返却値

同じ内容ならばtrue,違ったらfalseを返す



477
478
479
 
# File 'lib/Miyako/API/sprite_list.rb', line 477

def ==(other)
  self.eql?(other)
end

#[](name) ⇒ Object

名前と関連付けられたスプライトを取得する

関連付けられているスプライトが見つからなければnilが返る 例:a=SpriteList(pair(:a),pair(:b),pair(:c),pair(:d))

a[:c] => spr(:c)
a[:q] => nil
name

名前

返却値

名前に関連付けられたスプライト



855
856
857
858
 
# File 'lib/Miyako/API/sprite_list.rb', line 855

def [](name)
  pair = @list.find{|pair| pair.name == name }
  return pair ? pair.body : nil
end

#[]=(name, sprite) ⇒ Object

名前と関連付けられたスプライトを置き換える

名前に対応したスプライトを、引数で指定したものに置き換える。 ただし、まだ名前が登録されていないときは、新規追加と同じになる。 新規追加のときはSpriteList#pushと同じ 例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d))=spr(:e)

=> SpriteList(pair(:a),pair(:b),pair(:c),pair(:d),pair(:e))

例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d))=spr(:b2)

=> SpriteList(pair(:a),pair(:b2),pair(:c),pair(:d))
name

名前

sprite

スプライト

返却値

登録された自分自身



871
872
873
874
875
 
# File 'lib/Miyako/API/sprite_list.rb', line 871

def []=(name, sprite)
  return self.push([name, sprite]) unless self.names.include?(name)
  @list[self.names.index(name)].body = sprite
  return self
end

#add(name, sprite) ⇒ Object

名前・スプライトを登録する

リストに名前・スプライトをリストの後ろに追加する 効果はSpriteList#push,<<と同じ

name

スプライト名

sprite

スプライト本体

返却値

追加した自分自身を渡す



487
488
489
 
# File 'lib/Miyako/API/sprite_list.rb', line 487

def add(name, sprite)
  self.push([name, sprite])
end

#all ⇒ Object

スプライト名配列を取得する

SpriteList#show,hideメソッドを呼び出す際、すべての要素を表示・非表示にするときに使う

返却値

スプライト名配列



268
269
270
 
# File 'lib/Miyako/API/sprite_list.rb', line 268

def all
  @list.map{|pair| pair.name }
end

#assoc(name) ⇒ Object

スプライト名を探し、あればその対を返す

引数で渡された名前を元に、リストから探し出す。 (内部でHash#assocを呼び出し)

name

検索対象のスプライト名

返却値

見つかればListPair構造体、無ければnil



371
372
373
 
# File 'lib/Miyako/API/sprite_list.rb', line 371

def assoc(name)
  @list.find(nil){|pair| pair.name == name }
end

#clear ⇒ Object

リストの中身を消去する

リストに登録されているスプライト名・スプライト本体への登録を解除する



1011
1012
1013
 
# File 'lib/Miyako/API/sprite_list.rb', line 1011

def clear
  @list.clear
end

#combination(n, &block) ⇒ Object

自身での組み合わせを配列として返す

例:a=SpriteList(pair(:a),pair(:b),pair(:c))

a.combination(1)
=>[[pair(:a)],[pair(:b)],[pair(:c)]]
a.combination(2)
=>[[pair(:a),pair(:b)],[pair(:a),pair(:c)],[pair(:b),pair(:c)]]
a.combination(3)
=>[[pair(:a),pair(:b),pair(:c)]]

自分自身を配列化(to_ary)し、サイズnの組み合わせをすべて求めて配列化したものを Enumeratorとして返す

n

組み合わせのサイズ

返却値

Enumerator(ただしブロックを渡すと配列)



785
786
787
 
# File 'lib/Miyako/API/sprite_list.rb', line 785

def combination(n, &block)
  self.to_a.combination(n, &block)
end

#concat(other) ⇒ Object

別のSpriteListと破壊的につなげる

自分自身にotherで指定したListの要素をつなげる。 ただし、既に自分自身に登録されている要素は追加しない。 (例)a=SpriteList(pair(:a),pair(:b)(b1),pair(:c))

b=SpriteList(pair(:b)(b2),pair(:d),pair(:e))
a.concat(b)
  =>a=SpriteList(pair(:a),pair(:b)(b1),pair(:c),pair(:d),pair(:e))
    b=SpriteList(pair(:b)(b2),pair(:d),pair(:e))
返却値

自分自身を返す



690
691
692
693
 
# File 'lib/Miyako/API/sprite_list.rb', line 690

def concat(other)
  other.each{|pair| self.add(pair[0],pair[1].dup) unless self.has_name?(pair[0]) }
  self
end

#cycle(&block) ⇒ Object

名前-スプライトの対を繰り返し取得する

インスタンスを配列化し、周回して要素を取得できるEnumeratorを生成する 例:a=SpriteList(pair(:a),pair(:b),pair(:c)).cycle

=>pair(:a),pair(:b),pair(:c),pair(:a),pair(:b),pair(:c),pair(:a)...
返却値

生成されたEnumerator



722
723
724
725
 
# File 'lib/Miyako/API/sprite_list.rb', line 722

def cycle(&block)
  return self.to_enum(:cycle) unless block_given?
  self.to_a.cycle(&block)
end

#delete(name) ⇒ Object

指定した数の要素を先頭から取り除く

SpriteListの先頭からn個の要素を取り除いて、新しいSpriteListとする。 nがマイナスの時は、後ろからn個の要素を取り除く。 nが0の時は、空のSpriteListを返す。 自分自身に何も登録されていなければnilを返す (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.delete(:b)
  =>a=SpriteList(pair(:a),pair(:c))
    b=SpriteList(pair(:b))
b=a.delete(:d)
  =>a=SpriteList(pair(:a),pair(:b),pair(:c))
    b=nil
n

取り除く要素数。省略時は1

返却値

取り除いたSpriteListPair



602
603
604
605
606
607
 
# File 'lib/Miyako/API/sprite_list.rb', line 602

def delete(name)
  pair = @list.find{|pair| pair.name == name}
  return nil unless pair
  @list.delete(pair)
  pair
end

#delete_at(idx) ⇒ Object

指定したインデックスの要素を取り除く

SpriteListの先頭からn個の要素を取り除いて、新しいSpriteListとする。 nがマイナスの時は、後ろからn個の要素を取り除く。 nが0の時は、空のSpriteListを返す。 自分自身に何も登録されていなければnilを返す (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.delete_at(2)
  =>a=SpriteList(pair(:a),pair(:b))
    b=SpriteList(pair(:c))
b=a.delete_at(3)
  =>a=SpriteList(pair(:a),pair(:b),pair(:c))
    b=nil
idx

取り除く要素数。省略時は1

返却値

取り除いた要素から作られたSpriteList



623
624
625
 
# File 'lib/Miyako/API/sprite_list.rb', line 623

def delete_at(idx)
  self.delete(@list[idx])
end

#delete_if ⇒ Object

ブロックの評価結果が真のときのみ削除するSpriteListを作成

SpriteListの複製を作り、各要素でブロックを評価したときに、真になった要素は削除される。 引数は、各要素を示すListPari構造体インスタンスが渡ってくる。 (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.delete_if{|pair| pair[0] == :b}
  =>a=SpriteList(pair(:a),pair(:b),pair(:c))
    b=SpriteList(pair(:b))
返却値

取り除いた後のSpriteList



635
636
637
638
639
 
# File 'lib/Miyako/API/sprite_list.rb', line 635

def delete_if
  ret = self.deep_dup
  ret.each{|pair| ret.delete(pair) if yield(*pair)}
  ret
end

#delete_if! ⇒ Object

ブロックの評価結果が真のときのみ破壊的に削除する

自分自身に対して、各要素でブロックを評価したときに、真になった要素は削除される。 引数は、各要素を示すListPari構造体インスタンスが渡ってくる。 (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.delete_if!{|pair| pair[0] == :b}
  =>a=SpriteList(pair(:a),pair(:c))
    b=SpriteList(pair(:b))
返却値

取り除いた後のSpriteList



663
664
665
666
 
# File 'lib/Miyako/API/sprite_list.rb', line 663

def delete_if!
  self.each{|pair| self.delete(pair) if yield(*pair)}
  self
end

#dispose ⇒ Object

オブジェクトを解放する



1016
1017
1018
1019
 
# File 'lib/Miyako/API/sprite_list.rb', line 1016

def dispose
  @list.clear
  @list = nil
end

#each ⇒ Object

ブロックを受け取り、リストの各要素にたいして処理を行う

ブロック引数には、||が渡ってくる 名前が登録されている順に渡ってくる

返却値

自分自身を帰す



224
225
226
227
 
# File 'lib/Miyako/API/sprite_list.rb', line 224

def each
  return self.to_enum(:each) unless block_given?
  self.to_a.each{|pair| yield pair}
end

#each_index ⇒ Object

ブロックを受け取り、配列インデックスにたいして処理を行う

ブロック引数には、|スプライト名に対応する配列インデックス|の配列として渡ってくる 0,1,2,…の順に渡ってくる

返却値

自分自身を帰す



260
261
262
263
 
# File 'lib/Miyako/API/sprite_list.rb', line 260

def each_index
  return self.to_enum(:each_index) unless block_given?
  @list.length.times{|idx| yield idx}
end

#each_name ⇒ Object

ブロックを受け取り、名前リストの各要素にたいして処理を行う

ブロック引数には、|スプライト名|が渡ってくる 名前が登録されている順に渡ってくる

返却値

自分自身を帰す



242
243
244
245
 
# File 'lib/Miyako/API/sprite_list.rb', line 242

def each_name
  return self.to_enum(:each_name) unless block_given?
  @list.each{|pair| yield pair.name}
end

#each_pair ⇒ Object

ブロックを受け取り、スプライト名リストの各要素にたいして処理を行う

ブロック引数には、|スプライト名,スプライト本体|が渡ってくる 名前が登録されている順に渡ってくる

返却値

自分自身を帰す



233
234
235
236
 
# File 'lib/Miyako/API/sprite_list.rb', line 233

def each_pair
  return self.to_enum(:each_pair) unless block_given?
  @list.each{|pair| yield *pair}
end

#each_value ⇒ Object

ブロックを受け取り、値リストの各要素にたいして処理を行う

ブロック引数には、|スプライト本体|の配列として渡ってくる 名前が登録されている順に渡ってくる

返却値

自分自身を帰す



251
252
253
254
 
# File 'lib/Miyako/API/sprite_list.rb', line 251

def each_value
  return self.to_enum(:each_value) unless block_given?
  @list.each{|pair| yield pair.body}
end

#empty? ⇒ Boolean

リストが空っぽかどうか確かめる

リストに何も登録されていないかどうか確かめる

返却値

空っぽの時はtrue、なにか登録されているときはfalse

Returns:

  • (Boolean) 


296
297
298
 
# File 'lib/Miyako/API/sprite_list.rb', line 296

def empty?
  @list.empty?
end

#eql?(other) ⇒ Boolean

内容が同じかどうか比較する

リストに含まれるスプライト名(順番も)・値が同じかどうか比較する

返却値

同じときはtrue、違うときはfalseを返す

Returns:

  • (Boolean) 


307
308
309
310
311
312
313
 
# File 'lib/Miyako/API/sprite_list.rb', line 307

def eql?(other)
  return false unless other.class.method_defined?(:index)
  @list.find{|pair|
    self.index(pair) == other.index(pair) &&
    pair.body.eql?(other[pair.name].body)
  } != nil
end

#fetch(name, default = nil) {|ret| ... } ⇒ Object

名前に対して値を渡す

仕様はHash#fetchと同じ

Yields:

  • (ret) 


1023
1024
1025
1026
1027
1028
 
# File 'lib/Miyako/API/sprite_list.rb', line 1023

def fetch(name, default = nil, &block)
  ret = @list.find(nil){|pair| pair.name == name}
  ret = default unless ret
  yield ret if block_given?
  ret
end

#first(n = 1) ⇒ Object

リストの先頭要素を求める

リストの先頭からn要素をSpriteListとして返す。 リストが空のとき、nが0のときはnilを返す

n

先頭からの数。省略時は1

返却値

先頭からn個の要素を設定したSpriteList



399
400
401
402
403
 
# File 'lib/Miyako/API/sprite_list.rb', line 399

def first(n=1)
  return nil if @list.empty?
  return nil if n == 0
  SpriteList.new(@list.first(n))
end

#has_key?(name) ⇒ Boolean

リストに名前が登録されているか確認する

スプライト名リスト内に、引数で指定した名前が含まれているか調べる (include?メソッドと同じ)

name

検索対象の名前

返却値

名前が含まれていればtrue、含まれていなければfalseと返す

Returns:

  • (Boolean) 


320
321
322
 
# File 'lib/Miyako/API/sprite_list.rb', line 320

def has_key?(name)
  self.names.include?(name)
end

#has_name?(name) ⇒ Boolean

リストに名前が登録されているか確認する

スプライト名リスト内に、引数で指定した名前が含まれているか調べる (include?メソッドと同じ)

name

検索対象の名前

返却値

名前が含まれていればtrue、含まれていなければfalseと返す

Returns:

  • (Boolean) 


329
330
331
 
# File 'lib/Miyako/API/sprite_list.rb', line 329

def has_name?(name)
  self.names.include?(name)
end

#has_value?(value) ⇒ Boolean

リストにスプライトが登録されているか確認する

スプライトリスト内に、引数で指定したスプライトが含まれているか調べる

value

検索対象のスプライト

返却値

スプライトが含まれていればtrue、含まれていなければfalseと返す

Returns:

  • (Boolean) 


346
347
348
 
# File 'lib/Miyako/API/sprite_list.rb', line 346

def has_value?(value)
  self.values.include?(value)
end

#hide(*params) ⇒ Object

要素全体もしくは一部を描画不可能状態にする

他のhideメソッドとの違いは、名前のリストを引数に取れること(省略可)。 paramsで指定した名前に対応したスプライトのみ描画不可能にする paramsの省略時は自分自身を描画不可にする(現在、どの要素が描画不可になっているかは考えない。他クラスのhideと同じ動作) すべての要素を描画不可能にしたいときは、引数にSpriteList#allを使用する paramsに登録されていない名前が含まれているときは無視される また、ブロック(名前nameとスプライトbodyが引数)を渡したときは、リストに渡した名前一覧のうち、 ブロックを評価した結果がtrueのときのみ描画可能にする。 (引数paramsを省略したときは、すべての要素に対してブロックを評価すると見なす)

params

表示対象に名前リスト。



1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
 
# File 'lib/Miyako/API/sprite_list.rb', line 1237

def hide(*params)
  if block_given?
    if params == []
      @list.each{|pair| pair.body.hide if yield(pair.name, pair.body) }
    else
      @list.each{|pair|
        next unless params.include?(pair.name)
        pair.body.hide if yield(pair.name, pair.body)
      }
    end
  elsif params == []
    self.visible = false
  else
    @list.each{|pair| pair.body.hide if params.include?(pair.name) }
  end
end

#hide_only(*params) ⇒ Object

要素全体もしくは一部のみ描画不可能状態にする

paramsで指定した名前に対応したスプライトのみ描画不可能にし、それ以外を描画可能にする paramsに登録されていない名前が含まれているときは無視される paramsを省略したときは、すべての要素を描画不可能にする また、ブロック(名前nameとスプライトbodyが引数)を渡したときは、リストに渡した名前一覧のうち、 ブロックを評価した結果がtrueのときのみ描画可能にする。

params

表示対象に名前リスト。



1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
 
# File 'lib/Miyako/API/sprite_list.rb', line 1285

def hide_only(*params)
  if block_given?
    if params == []
      @list.each{|pair| yield(pair.name, pair.body) ? pair.body.hide : pair.body.show }
    else
      @list.each{|pair|
        next unless params.include?(pair.name)
        yield(pair.name, pair.body) ? pair.body.hide : pair.body.show
      }
    end
  elsif params == []
    @list.each{|pair| pair.body.hide }
  else
    @list.each{|pair| params.include?(pair.name) ? pair.body.hide : pair.body.show }
  end
end

#include?(name) ⇒ Boolean

リストに名前が登録されているか確認する

スプライト名リスト内に、引数で指定した名前が含まれているか調べる (has_name?メソッドと同じ)

name

検索対象の名前

返却値

名前が含まれていればtrue、含まれていなければfalseと返す

Returns:

  • (Boolean) 


338
339
340
 
# File 'lib/Miyako/API/sprite_list.rb', line 338

def include?(name)
  self.names.include?(name)
end

#index(name) ⇒ Object

名前が何番目にあるかを求める

スプライト名リスト中、指定したスプライト名のインデックスを求める (内部でHash#indexメソッドを呼び出している)

name

検索対象のスプライト名

返却値

名前が見つかったときはそのインデックス(0以上の整数)、無ければnil



390
391
392
 
# File 'lib/Miyako/API/sprite_list.rb', line 390

def index(pair)
  @list.index(pair)
end

#initialize_copy(obj) ⇒ Object

:nodoc:



185
186
187
188
189
 
# File 'lib/Miyako/API/sprite_list.rb', line 185

def initialize_copy(obj) #:nodoc:
  reflesh
  obj.names.each{|name| self.push([name, obj[name].deep_dup]) }
  @visible = obj.visible
end

#insert(key, name, value = nil) ⇒ Object

指定の名前の直前に名前を挿入する

配列上で、keyの前にnameを挿入する 例:SpriteList(pair(:a),pair(:b),pair(:c)).insert(:b, :d, spr(:d))

=> SpriteList(pair(:a),pair(:d),pair(:b),pair(:c))

例:SpriteList(pair(:a),pair(:b),pair(:c)).insert(:c, :a)

=> SpriteList(pair(:c),pair(:a),pair(:b))
key

挿入先の名前。この名前の直前に挿入する

name

挿入するスプライトの名前

value

(名前が未登録の時の)スプライト本体省略時はnil

返却値：自分自身を返す

Raises:



1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
 
# File 'lib/Miyako/API/sprite_list.rb', line 1040

def insert(key, name, value = nil)
  raise MiyakoValueError, "Illegal key! : #{key}" unless self.names.include?(key)
  return self if key == name
  pair = ListPair.new(name, value)
  unless value
    pair = @list.find{|pair| pair.name == name}
    raise MiyakoValueError, "name is not regist! : #{name}" unless pair
  end
  self.delete(name)
  @list.insert(self.names.index(key), pair)
  self
end

#insert_after(key, name, value = nil) ⇒ Object

指定の名前の直後に名前を挿入する

配列上で、keyの後ろにnameを挿入する 例:SpriteList(pair(:a),pair(:b),pair(:c)).insert_after(:b, :d, spr(:d))

=> SpriteList(pair(:a),pair(:b),,pair(:d)pair(:c))

例:SpriteList(pair(:a),pair(:b),pair(:c)).insert_after(:c, :b)

=> SpriteList(pair(:a),pair(:c),pair(:b))
key

挿入先の名前。この名前の直後に挿入する

name

挿入するスプライトの名前

value

(名前が未登録の時の)スプライト本体。省略時はnil

返却値：自分自身を返す

Raises:



1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
 
# File 'lib/Miyako/API/sprite_list.rb', line 1063

def insert_after(key, name, value = nil)
  raise MiyakoValueError, "Illegal key! : #{key}" unless self.names.include?(key)
  return self if key == name
  if value
    pair = ListPair.new(name, value)
  else
    pair = @list.find{|pair| pair.name == name}
    raise MiyakoValueError, "name is not regist! : #{name}" unless pair
  end
  self.delete(name)
  @list.insert(self.names.index(key)-@list.length, pair)
  self
end

#last(n = 1) ⇒ Object

リストの終端要素を求める

リストの終端からn要素をSpriteListとして返す。 リストが空のとき、nが0のときはnilを返す

n

終端からの数。省略時は1

返却値

終端からn個の要素を設定したSpriteList



410
411
412
413
414
 
# File 'lib/Miyako/API/sprite_list.rb', line 410

def last(n=1)
  return nil if @list.empty?
  return nil if n == 0
  SpriteList.new(@list.last(n))
end

#length ⇒ Object

リストの長さを求める

スプライトの登録数(リストの要素数)を返す (sizeメソッドと同じ)

返却値

リストの要素数(殻のときは0)



354
355
356
 
# File 'lib/Miyako/API/sprite_list.rb', line 354

def length
  @list.length
end

#merge(other) ⇒ Object

引数と自分自身との結果をマージする

otherで割り付けられた名前のうち、自分では登録されていないものは新規登録する(方法はpushと同じ) 名前がバッティングしたときは自分自身の本体を優先する

other

マージするSpriteList

返却値

変更を加えた自分自身の複製



700
701
702
703
704
 
# File 'lib/Miyako/API/sprite_list.rb', line 700

def merge(other)
  ret = other.dup + self
  ret.names.each{|name| yield name, self[name], other[name] } if block_given?
  ret
end

#merge!(other) ⇒ Object

自分自身と引数との結果を破壊的にマージする

otherで割り付けられた名前のうち、自分では登録されていないものは新規登録する(方法はpushと同じ) 名前がバッティングしたときは自分自身の本体を優先する

other

マージするSpriteList

返却値

変更された自分自身



711
712
713
714
715
 
# File 'lib/Miyako/API/sprite_list.rb', line 711

def merge!(other)
  self.replace(other+self)
  self.names.each{|name| yield name, self[name], other[name] } if block_given?
  self
end

#move!(dx, dy) ⇒ Object

各要素の位置を変更する(変化量を指定)

ブロックを渡したとき、戻り値としてとした配列を返すと、 それがその要素での移動量となる。 ブロックの引数は、|ListPair, インデックス(0,1,2,…), dx, dy|となる。 (例)a=SpriteList(pair(:a), pair(:b), pair(:c))

#各スプライトの位置=すべて(10,15)
a.move!(20,25) => pair(:a)の位置:(30,40)
                  pair(:b)の位置:(30,40)
                  pair(:c)の位置:(30,40)
a.move!(20,25){|pair,i,dx,dy|
  [i*dx, i*dy]
}
               => pair(:a)の位置:(10,15)
                  pair(:b)の位置:(30,40)
                  pair(:c)の位置:(50,65)
dx

移動量(x方向)。単位はピクセル

dy

移動量(y方向)。単位はピクセル

返却値

自分自身を返す



940
941
942
943
944
945
946
947
948
949
 
# File 'lib/Miyako/API/sprite_list.rb', line 940

def move!(dx, dy)
  if block_given?
    @list.each_with_index{|pair, i|
      pair.body.move!(*(yield pair, i, dx, dy))
    }
  else
    @list.each{|pair| pair.body.move!(dx, dy) }
  end
  self
end

#move_to!(x, y) ⇒ Object

各要素の位置を変更する(変化量を指定)

ブロックを渡したとき、戻り値としてとした配列を返すと、 それがその要素での移動量となる。 ブロックの引数は、|ListPair, インデックス(0,1,2,…), x, y|となる。 (例)a=SpriteList(pair(:a), pair(:b), pair(:c))

#各スプライトの位置=すべて(10,15)
a.move!(20,25) => pair(:a)の位置:(20,25)
                  pair(:b)の位置:(20,25)
                  pair(:c)の位置:(20,25)
a.move!(20,25){|pair,i,dx,dy|
  [i*dx, i*dy]
}
               => pair(:a)の位置:( 0, 0)
                  pair(:b)の位置:(20,25)
                  pair(:c)の位置:(40,50)
x

移動先位置(x方向)。単位はピクセル

y

移動先位置(y方向)。単位はピクセル

返却値

自分自身を返す



969
970
971
972
973
974
975
976
977
978
 
# File 'lib/Miyako/API/sprite_list.rb', line 969

def move_to!(x, y)
  if block_given?
    @list.each_with_index{|pair, i|
      pair.body.move_to!(*(yield pair, i, x, y))
    }
  else
    @list.each{|pair| pair.body.move_to!(x, y) }
  end
  self
end

#name(value) ⇒ Object

スプライトが登録されている名前を求める

実際のスプライト本体から、登録されているスプライトを探す。 見つかれば、それに対応する名前を返す。 (内部でHash#keyメソッドを呼び出している)

name

検索対象のスプライト名

返却値

名前が見つかったときはそのスプライト名、無ければnil



381
382
383
 
# File 'lib/Miyako/API/sprite_list.rb', line 381

def name(value)
  @list.find(nil){|pair| pair.value.eql?(value) }
end

#names ⇒ Object

スプライト名配列を取得する

名前が登録されている順に渡ってくる

返却値

スプライト名配列



275
276
277
 
# File 'lib/Miyako/API/sprite_list.rb', line 275

def names
  @list.map{|pair| pair.name }
end

#pairs ⇒ Object

名前-本体ペア配列を取得する

名前が登録されている順にListPair構造体の構造体を構成して返す

返却値

ListPair構造体の配列



289
290
291
 
# File 'lib/Miyako/API/sprite_list.rb', line 289

def pairs
  @list
end

#pairs_at(*names) ⇒ Object

名前の一覧から新しいSpriteListを生成する

リストの順番はnamesの順番と同じ 自分自身に登録されていない名前があったときはnilが登録される 例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d)).pairs_at(:b, :d)

=> [pair(:b),pair(:d)]

例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d)).pairs_at(:b, :e)

=> [pair(:b),nil]
names

取り出した名前のリスト名前

返却値

生成されたSpriteList



886
887
888
 
# File 'lib/Miyako/API/sprite_list.rb', line 886

def pairs_at(*names)
  SpriteList.new(@list.select{|pair| names.include?(pair.name)})
end

#permutation(n, &block) ⇒ Object

自身での順列を配列として返す

自分自身を配列化(to_ary)し、サイズnの順列をすべて求めて配列化したものを Enumeratorとして返す 例:a=SpriteList(pair(:a),pair(:b),pair(:c))

a.permutation(1)
=>[[pair(:a)],[pair(:b)],[pair(:c)]]
a.permutation(2)
=>[[pair(:a),pair(:b)],[pair(:a),pair(:c)],
   [pair(:b),pair(:a)],[pair(:b),pair(:c)],
   [pair(:c),pair(:a)],[pair(:c),pair(:b)]]
a.permutation(3)
=>[[pair(:a),pair(:b),pair(:c)],[pair(:a),pair(:c),pair(:b)],
   [pair(:b),pair(:a),pair(:c)],[pair(:b),pair(:c),pair(:a)],
   [pair(:c),pair(:a),pair(:b)],[pair(:c),pair(:b),pair(:a)]]
n

順列のサイズ

返却値

Enumerator(ただしブロックを渡すと配列)



805
806
807
 
# File 'lib/Miyako/API/sprite_list.rb', line 805

def permutation(n, &block)
  self.to_a.permutation(n, &block)
end

#pickup(*names) ⇒ Object

指定の名前の順番に最前面から表示するように入れ替える

namesで示した名前一覧の順番を逆転させて、配列の一番後ろに入れ替える。 (renderメソッドは、配列の一番後ろのスプライトが一番前に描画されるため 存在しない名前を指定すると例外MiyakoErrorが発生する (例)

:a,:b,:c,:d,:e]のとき、pickup(:d,:a,:e) -> [:b,:c,:e,:a,:d
names

入れ替えるスプライトの名前一覧

返却値：入れ替えたSpriteListの複製を返す



1156
1157
1158
1159
 
# File 'lib/Miyako/API/sprite_list.rb', line 1156

def pickup(*names)
  ret = self.dup
  ret.pickup!(*names)
end

#pickup!(*names) ⇒ Object

指定の名前の順番に最前面から表示するように破壊的に入れ替える

namesで示した名前一覧の順に、配列の一番後ろに入れ替える。 (renderメソッドは、配列の一番後ろのスプライトが一番前に描画されるため 存在しない名前を指定すると例外MiyakoErrorが発生する (例)

:a,:b,:c,:d,:e]のとき、pickup(:d,:a,:e) -> [:b,:c,:e,:a,:d
names

入れ替えるスプライトの名前一覧

返却値：自分自身を返す



1169
1170
1171
1172
 
# File 'lib/Miyako/API/sprite_list.rb', line 1169

def pickup!(*names)
  names.reverse.each{|name| pickup_inner(name) }
  self
end

#pop ⇒ Object

リストの終端から名前・スプライトの対を取り出す

リストに名前・スプライトをリストの終端から取り除いて、取り除いた対を返す

返却値

終端にあった名前に対応するListPair構造体



513
514
515
516
 
# File 'lib/Miyako/API/sprite_list.rb', line 513

def pop
  return nil if @list.empty?
  @list.pop
end

#push(*pairs) ⇒ Object

名前・スプライトの対を登録する

リストに名前・スプライトをリストの後ろに追加する 効果はSpriteList#addと同じだが、複数の対を登録できることが特徴 (例)push()

push([name1,sprite1],[name2,sprite2])
pairs

名前とスプライトの対を配列にしたもの。対は、として渡す。

返却値

追加した自分自身を渡す



498
499
500
501
502
503
504
505
506
507
508
 
# File 'lib/Miyako/API/sprite_list.rb', line 498

def push(*pairs)
  pairs.each{|name, sprite|
    unless sprite.class.include?(SpriteBase) || sprite.class.include?(SpriteArray)
      raise MiyakoValueError, "Illegal Sprite!"
    end
    pair = ListPair.new(name, sprite)
    @list.reject!{|pair| pair.name == name}
    @list <<  pair
  }
  return self
end

#reject ⇒ Object

ブロックの評価結果が真のときのみ削除するSpriteListを作成

SpriteListの複製を作り、各要素でブロックを評価したときに、真になった要素は削除される。 引数は、各要素を示すListPari構造体インスタンスが渡ってくる。 (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.reject{|pair| pair[0] == :b}
  =>a=SpriteList(pair(:a),pair(:b),pair(:c))
    b=SpriteList(pair(:b))
返却値

取り除いた後のSpriteList



649
650
651
652
653
 
# File 'lib/Miyako/API/sprite_list.rb', line 649

def reject
  ret = self.deep_dup
  ret.each{|pair| ret.delete(pair) if yield(*pair)}
  ret
end

#reject! ⇒ Object

ブロックの評価結果が真のときのみ破壊的に削除する

自分自身に対して、各要素でブロックを評価したときに、真になった要素は削除される。 引数は、各要素を示すListPari構造体インスタンスが渡ってくる。 (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.reject!{|pair| pair[0] == :b}
  =>a=SpriteList(pair(:a),pair(:c))
    b=SpriteList(pair(:b))
返却値

取り除いた後のSpriteList



676
677
678
679
 
# File 'lib/Miyako/API/sprite_list.rb', line 676

def reject!
  self.each{|pair| self.delete(pair) if yield(*pair)}
  self
end

#render ⇒ Object

配列の要素を画面に描画する

配列の先頭から順にrenderメソッドを呼び出す。

返却値

自分自身を帰す



1336
1337
1338
1339
1340
 
# File 'lib/Miyako/API/sprite_list.rb', line 1336

def render
  return self unless @visible
  self.sprite_only.each{|pair| pair[1].render }
  return self
end

#render_d(dx, dy) ⇒ Object

位置を指定して画面への描画を指示するメソッドのテンプレート

オブジェクトで保持している位置情報ではなく、引数で渡された位置に描画する 基本的に、メソッドのオーバーライドにより機能するが、pos,move_to!メソッドを持っているときは、 これらのメソッドを呼び出して同じ動作を行うが処理速度的に課題あり ただし、上記のメソッドを持っていない場合は、単純にrenderメソッドを呼び出す

x

描画位置のx座標

y

描画位置のy座標

返却値

自分自身を返す



1394
1395
1396
1397
1398
1399
1400
 
# File 'lib/Miyako/API/sprite_list.rb', line 1394

def render_d(dx, dy)
  return self.each{|e|
    obj = pair[1]
    cl  = obj.class
    obj.render_d(dx, dy) if  e.class.include?(SpriteBase) || e.class.include?(SpriteArray)
  }
end

#render_to(dst) ⇒ Object

配列の要素を対象の画像に描画する

配列の先頭から順にrender_toメソッドを呼び出す。

dst

描画対象の画像インスタンス

返却値

自分自身を帰す



1346
1347
1348
1349
1350
 
# File 'lib/Miyako/API/sprite_list.rb', line 1346

def render_to(dst)
  return self unless @visible
  self.sprite_only.each{|pair| pair[1].render_to(dst) }
  return self
end

#render_xy(x, y) ⇒ Object

位置を指定して画面への描画を指示するメソッドのテンプレート

オブジェクトで保持している位置情報ではなく、引数で渡された位置に描画する 基本的に、メソッドのオーバーライドにより機能するが、pos,move_to!メソッドを持っているときは、 これらのメソッドを呼び出して同じ動作を行うが処理速度的に課題あり ただし、上記のメソッドを持っていない場合は、単純にrenderメソッドを呼び出す

x

描画位置のx座標

y

描画位置のy座標

返却値

自分自身を返す



1361
1362
1363
1364
1365
1366
1367
 
# File 'lib/Miyako/API/sprite_list.rb', line 1361

def render_xy(x, y)
  return self.each{|pair|
    obj = pair[1]
    cl  = obj.class
    obj.render_xy(x, y) if cl.include?(SpriteBase) || cl.include?(SpriteArray)
  }
end

#render_xy_to(dst, x, y) ⇒ Object

位置を指定して画像への描画を指示するメソッドのテンプレート

オブジェクトで保持している位置情報ではなく、引数で渡された位置に描画する 基本的に、メソッドのオーバーライドにより機能するが、pos,move_to!メソッドを持っているときは、 これらのメソッドを呼び出して同じ動作を行うが、処理速度的に課題あり ただし、上記のメソッドを持っていない場合は、単純にrender_toメソッドを呼び出す

dst

対象の画像

x

描画位置のx座標

y

描画位置のy座標

返却値

自分自身を返す



1378
1379
1380
1381
1382
1383
1384
 
# File 'lib/Miyako/API/sprite_list.rb', line 1378

def render_xy_to(dst, x, y)
  return self.each{|pair|
    obj = pair[1]
    cl  = obj.class
    obj.render_xy_to(dst, x, y) if cl.include?(SpriteBase) || cl.include?(SpriteArray)
  }
end

#replace(other) ⇒ Object

内容を引数のものに置き換える

現在登録されているデータをいったん解除し、 引数として渡ってきたSpriteListの無いようにデータを置き換える 例:a=SpriteList(pair(:a),pair(:b),pair(:c),pair(:d))

a.replace(SpriteList(pair(:e),pair(:f),pair(:g),pair(:h)))
=>a=SpriteList(pair(:e),pair(:f),pair(:g),pair(:h))
other

置き換え元のSpriteList

返却値

置き換えた自分自身



819
820
821
822
823
 
# File 'lib/Miyako/API/sprite_list.rb', line 819

def replace(other)
  self.clear
  other.to_a.each{|pair| self.add(pair[0], pair[1].dup)}
  self
end

#reset ⇒ Object

各要素のアニメーションを先頭パターンに戻す

各要素のresetメソッドを呼び出す

返却値

自分自身を返す



1321
1322
1323
1324
 
# File 'lib/Miyako/API/sprite_list.rb', line 1321

def reset
  self.sprite_only.each{|pair| pair[1].reset }
  return self
end

#reverse ⇒ Object

名前の順番を反転する

名前の順番を反転した、自分自身のコピーを生成する 例:a=SpriteList(pari(:a),pair(:b),pair(:c),pair(:d))

a.reverse
=>SpriteList(pari(:d),pair(:c),pair(:b),pair(:a))
  a=SpriteList(pari(:a),pair(:b),pair(:c),pair(:d))
返却値

名前を反転させた自分自身の複製を返す



832
833
834
835
 
# File 'lib/Miyako/API/sprite_list.rb', line 832

def reverse
  ret = self.dup
  ret.reverse!
end

#reverse! ⇒ Object

名前の順番を破壊的に反転する

例:a=SpriteList(pair(:a),pair(:b),pair(:c),pair(:d))

a.reverse!
=>SpriteList(pair(:d),pair(:c),pair(:b),pair(:a))
  a=SpriteList(pair(:d),pair(:c),pair(:b),pair(:a))
返却値

自分自身を帰す



843
844
845
846
 
# File 'lib/Miyako/API/sprite_list.rb', line 843

def reverse!
  @list.reverse!
  return self
end

#sample(n = nil) ⇒ Object

自身から要素をランダムに選ぶ

自分自身を配列化(to_ary)し、最大n個の要素(ListPair)をランダムに選び出して配列として返す 自分自身が空のときは、n=nilのときはnilを、n!=nilのときは空配列を返す 例:a=SpriteList(pair(:a),pair(:b),pair(:c))

a.sample(1)
=>[pair(:a)] or [pair(:b)] or [pair(:c)]
a.sample(2)
=>[pair(:a),pair(:b)] or [pair(:a),pair(:c)] or
  [pair(:b),pair(:a)] or [pair(:b),pair(:c)] or
  [pair(:c),pair(:a)] or [pair(:c),pair(:b)]
a.sample(3)
=>[pair(:a),pair(:b),pair(:c)] or [pair(:a),pair(:c),pair(:b)] or
  [pair(:b),pair(:a),pair(:c)] or [pair(:b),pair(:c),pair(:a)] or
  [pair(:c),pair(:a),pair(:b)] or [pair(:c),pair(:b),pair(:a)]
n

選び出す個数。n=nilのときは1個とみなす

返却値

選び出したListPairを配列化したもの



769
770
771
 
# File 'lib/Miyako/API/sprite_list.rb', line 769

def sample(n=nil)
  n ? self.to_a.sample(n) : self.to_a.sample
end

#shift(n = 1) ⇒ Object

指定した数の要素を先頭から取り除く

SpriteListの先頭からn個の要素を取り除いて、新しいSpriteListとする。 nがマイナスの時は、後ろからn個の要素を取り除く。 nが0の時は、空のSpriteListを返す。 自分自身に何も登録されていなければnilを返す (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.shift(1)
  =>a=SpriteList(pair(:b),pair(:c))
    b=SpriteList(pair(:a))
b=a.shift(2)
  =>a=SpriteList(pair(:c))
    b=SpriteList(pair(:a),pair(:b))
b=a.shift(0)
  =>a=SpriteList(pair(:a),pair(:b),pair(:c))
    b=SpriteList()

(例)a=SpriteList()

b=a.shift(1)
  =>a=SpriteList()
    b=nil
n

取り除く要素数。省略時は1

返却値

取り除いた要素から作られたSpriteList



582
583
584
585
586
 
# File 'lib/Miyako/API/sprite_list.rb', line 582

def shift(n = 1)
  return nil if @list.empty?
  return SpriteList.new if n == 0
  SpriteList.new(@list.shift(n))
end

#show(*params) ⇒ Object

要素全体もしくは一部を描画可能状態にする

他のshowメソッドとの違いは、名前のリストを引数に取れること(省略可)。 paramsで指定した名前に対応したスプライトのみ描画可能にする paramsの省略時は自分自身を描画可能にする(現在、どの要素が描画可能かは考えない。他クラスのshowと同じ動作) すべての要素を描画可能にしたいときは、引数にSpriteList#allを使用する paramsに登録されていない名前が含まれているときは無視される また、ブロック(名前nameとスプライトbodyが引数)を渡したときは、リストに渡した名前一覧のうち、 ブロックを評価した結果がtrueのときのみ描画可能にする。 (引数paramsを省略したときは、すべての要素に対してブロックを評価すると見なす)

params

表示対象に名前リスト。



1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
 
# File 'lib/Miyako/API/sprite_list.rb', line 1210

def show(*params)
  if block_given?
    if params == []
      @list.each{|pair| pair.body.show if yield(pair.name, pair.body) }
    else
      @list.each{|pair|
        next unless params.include?(pair.name)
        pair.body.show if yield(pair.name, pair.body)
      }
    end
  elsif params == []
    self.visible = true
  else
    @list.each{|pair| pair.body.show if params.include?(pair.name) }
  end
end

#show_only(*params) ⇒ Object

要素全体もしくは一部のみ描画可能状態にする

paramsで指定した名前に対応したスプライトのみ描画可能にし、それ以外を描画不可能にする paramsに登録されていない名前が含まれているときは無視される paramsを省略したときは、すべての要素を描画可能にする また、ブロック(名前nameとスプライトbodyが引数)を渡したときは、リストに渡した名前一覧のうち、 ブロックを評価した結果がtrueのときのみ描画可能にする。

params

表示対象に名前リスト。



1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
 
# File 'lib/Miyako/API/sprite_list.rb', line 1261

def show_only(*params)
  if block_given?
    if params == []
      @list.each{|pair| yield(pair.name, pair.body) ? pair.body.show : pair.body.hide }
    else
      @list.each{|pair|
        next unless params.include?(pair.name)
        yield(pair.name, pair.body) ? pair.body.show : pair.body.hide
      }
    end
  elsif params == []
    @list.each{|pair| pair.body.show }
  else
    @list.each{|pair| params.include?(pair.name) ? pair.body.show : pair.body.hide }
  end
end

#shuffle ⇒ Object

名前の順番をシャッフルしたSpriteListを返す

自分自身を複製し、登録されている名前の順番をシャッフルして返す 例:a=SpriteList(pair(:a),pair(:b),pair(:c))

a.shuffle
=>SpriteList(pair(:a),pair(:b),pair(:c)) or SpriteList(pair(:a),pair(:c),pair(:b)) or
  SpriteList(pair(:b),pair(:a),pair(:c)) or SpriteList(pair(:b),pair(:c),pair(:a)) or
  SpriteList(pair(:c),pair(:a),pair(:b)) or SpriteList(pair(:c),pair(:b),pair(:a))
  a=SpriteList(pair(:a),pair(:b),pair(:c))
返却値

シャッフルした自分自身の複製



736
737
738
 
# File 'lib/Miyako/API/sprite_list.rb', line 736

def shuffle
  self.dup.shuffle!
end

#shuffle! ⇒ Object

名前の順番をシャッフルする

自分自身で登録されている名前の順番をシャッフルする 例:a=SpriteList(pair(:a),pair(:b),pair(:c))

a.shuffle!
=>a=SpriteList(pair(:a),pair(:b),pair(:c)) or SpriteList(pair(:a),pair(:c),pair(:b)) or
    SpriteList(pair(:b),pair(:a),pair(:c)) or SpriteList(pair(:b),pair(:c),pair(:a)) or
    SpriteList(pair(:c),pair(:a),pair(:b)) or SpriteList(pair(:c),pair(:b),pair(:a))
返却値

シャッフルした自分自身



748
749
750
751
 
# File 'lib/Miyako/API/sprite_list.rb', line 748

def shuffle!
  @list.shuffle!
  self
end

#size ⇒ Object

リストの長さを求める

スプライトの登録数(リストの要素数)を返す (lengthメソッドと同じ)

返却値

リストの要素数(殻のときは0)



362
363
364
 
# File 'lib/Miyako/API/sprite_list.rb', line 362

def size
  @list.length
end

#slice(*names) ⇒ Object

指定した名前の要素を取り除いたSpriteListを取得する

登録されていない名前が指定されたときは何もしない (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.slice(:a,:b)
  =>a=SpriteList(pair(:c))
    b=SpriteList(pair(:a),pair(:b))
b=a.slice(:d,:b)
  =>a=SpriteList(pair(:a),pair(:c))
    b=SpriteList(pair(:b))
names

スプライト名のリスト

返却値

自分自身の複製から指定した名前の要素を取り除いたインスタンス



541
542
543
544
 
# File 'lib/Miyako/API/sprite_list.rb', line 541

def slice(*names)
  list = self.dup
  list.delete_if!{|name, sprite| !names.include?(name)}
end

#slice!(*names) ⇒ Object

指定した名前の要素を取り除く

登録されていない名前が指定されたときは何もしない (例)a=SpriteList(pair(:a),pair(:b),pair(:c))

b=a.slice!(:a,:b)
  =>a=SpriteList(pair(:c))
    b=SpriteList(pair(:c))
b=a.slice!(:d,:b)
  =>a=SpriteList(pair(:a),pair(:c))
    b=SpriteList(pair(:a),pair(:c))
names

スプライト名のリスト

返却値

更新した自分自身



557
558
559
 
# File 'lib/Miyako/API/sprite_list.rb', line 557

def slice!(*names)
  self.delete_if!{|name, sprite| !names.include?(name)}
end

#sprite_only ⇒ Object

スプライト以外のインスタンスを削除したSpriteListを生成する

新しいSpriteListを作成し、本体がnilや、SpriteBaseもしくはSpritArrayモジュールを mixinしていない対を削除する。

返却値

新しく生成したインスタンス



195
196
197
198
199
200
201
202
203
204
 
# File 'lib/Miyako/API/sprite_list.rb', line 195

def sprite_only
  ret = SpriteList.new
  @list.each{|pair|
    name = pair.name
    body = pair.body
    ret[name] = pair.value if !body.class.include?(SpriteBase) &&
                              !body.class.include?(SpriteArray)
  }
  return ret
end

#sprite_only! ⇒ Object

スプライト以外のインスタンスを破壊的に削除する

自分自身から、本体がnilや、SpriteBaseもしくはSpritArrayモジュールを mixinしていない対を削除する。

返却値

自分自身を帰す



210
211
212
213
214
215
216
217
218
 
# File 'lib/Miyako/API/sprite_list.rb', line 210

def sprite_only!
  @list.each{|pair|
    if !pair.body.class.include?(SpriteBase) &&
       !pair.body.class.include?(SpriteArray)
      @list.delete(pair)
    end
  }
  return self
end

#start ⇒ Object

各要素のアニメーションを開始する

各要素のstartメソッドを呼び出す

返却値

自分自身を返す



1305
1306
1307
1308
 
# File 'lib/Miyako/API/sprite_list.rb', line 1305

def start
  self.sprite_only.each{|pair| pair[1].start }
  return self
end

#stop ⇒ Object

各要素のアニメーションを停止する

各要素のstopメソッドを呼び出す

返却値

自分自身を返す



1313
1314
1315
1316
 
# File 'lib/Miyako/API/sprite_list.rb', line 1313

def stop
  self.sprite_only.each{|pair| pair[1].stop }
  return self
end

#swap(name1, name2) ⇒ Object

指定した要素の内容を入れ替える

例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d)).insert(:b, :d)

=> SpriteList(pair(:a),pair(:d),pair(:c),pair(:b))
_name1,name_

入れ替え対象の名前

返却値

自分自身を帰す

Raises:



1082
1083
1084
1085
1086
1087
1088
1089
1090
 
# File 'lib/Miyako/API/sprite_list.rb', line 1082

def swap(name1, name2)
  names = self.names
  raise MiyakoValueError, "Illegal name! : idx1:#{name1}" unless names.include?(name1)
  raise MiyakoValueError, "Illegal name! : idx2:#{name2}" unless names.include?(name2)
  idx1 = names.index(name1)
  idx2 = names.index(name2)
  @list[idx1], @list[idx2] = @list[idx2], @list[idx1]
  return self
end

#to_a ⇒ Object

リストを配列化する

インスタンスの内容を元に、配列を生成する。 各要素は、ListPair構造体 例:a=SpriteList(pair(:a),pair(:b),pair(:c)).to_a

=> [pair(:a),pair(:b),pair(:c)]
返却値

生成した配列



986
987
988
 
# File 'lib/Miyako/API/sprite_list.rb', line 986

def to_a
  self.to_ary
end

#to_ary ⇒ Object

リストを配列化する

インスタンスの内容を元に、配列を生成する。 各要素は、ListPair構造体 例:a=SpriteList(pair(:a),pair(:b),pair(:c)).to_ary

=> [pair(:a),pair(:b),pair(:c)]
返却値

生成した配列



996
997
998
 
# File 'lib/Miyako/API/sprite_list.rb', line 996

def to_ary
  @list.dup
end

#to_first(*names) ⇒ Object

配列の最初で、指定の名前の順番に描画するように入れ替える

namesで示した名前一覧の順番を逆転させて、配列の一番後ろに入れ替える。 (renderメソッドは、配列の一番後ろのスプライトが一番前に描画されるため 存在しない名前を指定すると例外MiyakoErrorが発生する (例)

:a,:b,:c,:d,:e]のとき、pickup(:d,:a,:e) -> [:d, :a, :e, :b,:c
names

入れ替えるスプライトの名前一覧

返却値：入れ替えたSpriteListの複製を返す



1115
1116
1117
1118
 
# File 'lib/Miyako/API/sprite_list.rb', line 1115

def to_first(*names)
  ret = self.dup
  ret.to_first!(*names)
end

#to_first!(*names) ⇒ Object

配列の最初で、指定の名前の順番に描画するように破壊的に入れ替える

namesで示した名前一覧の順番を逆転させて、配列の一番後ろに入れ替える。 (renderメソッドは、配列の一番後ろのスプライトが一番前に描画されるため 存在しない名前を指定すると例外MiyakoErrorが発生する (例)

:a,:b,:c,:d,:e]のとき、pickup(:d,:a,:e) -> [:b,:c,:e,:a,:d
names

入れ替えるスプライトの名前一覧

返却値：自分自身を返す



1128
1129
1130
1131
 
# File 'lib/Miyako/API/sprite_list.rb', line 1128

def to_first!(*names)
  names.reverse.each{|name| to_first_inner(name) }
  self
end

#to_hash ⇒ Object

スプライト名とスプライト本体とのハッシュを取得する

スプライト名とスプライト本体が対になったハッシュを作成して返す 例:SpriteList(pair(:a),pair(:b),pair(:c)).to_hash

=> {:a=>spr(:a),:b=>spr(:b),:c=>spr(:c)}
返却値

生成したハッシュ



1005
1006
1007
 
# File 'lib/Miyako/API/sprite_list.rb', line 1005

def to_hash
  @list.inject({}){|r, pair| r[pair.name] = pair.value}
end

#to_last(*names) ⇒ Object

配列の最後で、指定の名前の順番に描画するように入れ替える

配列の最後に、namesで示した名前一覧の順に要素を入れ替える。 (renderメソッドは、配列の一番後ろのスプライトが一番前に描画されるため 存在しない名前を指定すると例外MiyakoErrorが発生する (例)

:a,:b,:c,:d,:e]のとき、pickup(:d,:a,:e) -> [:b,:c,:d,:a,:e
names

入れ替えるスプライトの名前一覧

返却値：入れ替えたSpriteListの複製を返す



1182
1183
1184
1185
 
# File 'lib/Miyako/API/sprite_list.rb', line 1182

def to_last(*names)
  ret = self.dup
  ret.to_last!(*names)
end

#to_last!(*names) ⇒ Object

配列の最後で、指定の名前の順番に描画するように破壊的に入れ替える

配列の最後に、namesで示した名前一覧の順に要素を入れ替える。 (renderメソッドは、配列の一番後ろのスプライトが一番前に描画されるため 存在しない名前を指定すると例外MiyakoErrorが発生する (例)

:a,:b,:c,:d,:e]のとき、pickup(:d,:a,:e) -> [:b,:c,:d,:a,:e
names

入れ替えるスプライトの名前一覧

返却値：自分自身を返す



1195
1196
1197
1198
 
# File 'lib/Miyako/API/sprite_list.rb', line 1195

def to_last!(*names)
  names.each{|name| pickup_inner(name) }
  self
end

#to_s ⇒ Object

オブジェクトを文字列に変換する

いったん、名前とスプライトとの対の配列に変換し、to_sメソッドで文字列化する。 例:[[name1, sprite1], [name2, sprite2],…]

返却値

変換した文字列



1406
1407
1408
 
# File 'lib/Miyako/API/sprite_list.rb', line 1406

def to_s
  self.to_a.to_s
end

#unshift(name, sprite) ⇒ Object

名前・スプライトを登録する

リストに名前・スプライトをリストの先頭に追加する (先頭に追加することがSpriteList#<<,add,pushとの違い)

name

スプライト名

sprite

スプライト本体

返却値

追加した自分自身を渡す



524
525
526
527
528
 
# File 'lib/Miyako/API/sprite_list.rb', line 524

def unshift(name, sprite)
  @list.reject!{|pair| pair.name == name}
  @list.unshift(ListPair.new(name, sprite))
  return self
end

#update_animation ⇒ Object

各要素のアニメーションを更新する

各要素のupdate_animationメソッドを呼び出す

返却値

各要素のupdate_spriteメソッドを呼び出した結果を配列で返す



1329
1330
1331
 
# File 'lib/Miyako/API/sprite_list.rb', line 1329

def update_animation
  self.sprite_only.map{|pair| pair[1].update_animation }
end

#values ⇒ Object

スプライト配列を取得する

名前が登録されている順に渡ってくる

返却値

スプライト本体配列



282
283
284
 
# File 'lib/Miyako/API/sprite_list.rb', line 282

def values
  @list.map{|pair| pair.body }
end

#values_at(*names) ⇒ Object

名前の一覧から本体のリストを生成する

本体のみの配列を返す。要素の順番はnamesの順番と同じ 自分自身に登録されていない名前があったときはnilが登録される 例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d)).values_at(:b, :d)

=> [spr(:b),spr(:d)]

例:SpriteList(pair(:a),pair(:b),pair(:c),pair(:d)).values_at(:b, :e)

=> [spr(:b),nil]
names

取り出した名前のリスト名前

返却値

生成された配列



899
900
901
 
# File 'lib/Miyako/API/sprite_list.rb', line 899

def values_at(*names)
  @list.search{|pair| names.include?(pair.name)}.map{|pair| pair.body }
end

#zip(*lists, &block) ⇒ Object

SpriteListを配列化し、同じ位置の要素を一つの配列にまとめる

自分自身に登録されていない名前があったときはnilが登録される 例:SpriteList(pair(:a),pair(:b),pair(:c)).zip(SpriteList(pair(:d),pair(:e),pair(:f))

=> [[pair(:a),pair(:d)],[pair(:b),pair(:e)],[pair(:c),pair(:f)]]

例:SpriteList(pair(:a),pair(:b)).zip(SpriteList(pair(:d),pair(:e),pair(:f))

=> [[pair(:a),pair(:d)],[pair(:b),pair(:e)]]

例:SpriteList(pair(:a),pair(:b),pair(:c)).zip(SpriteList(pair(:d),pair(:e))

=> [[pair(:a),pair(:d)],[pair(:b),pair(:e)],[pair(:c),nil]]

例:SpriteList(pair(:a),pair(:b),pair(:c)).zip(

    SpriteList(pair(:d),pair(:e),pair(:f),
    SpriteList(pair(:g),pair(:h),pair(:i))
=> [[pair(:a),pair(:d),pair(:g)],[pair(:b),pair(:e),pair(:h)],[pair(:c),pair(:f),pair(:i)]]
names

取り出した名前のリスト名前

返却値

生成されたSpriteList



917
918
919
920
 
# File 'lib/Miyako/API/sprite_list.rb', line 917

def zip(*lists, &block)
  lists = lists.map{|list| list.to_a}
  self.to_a.zip(*lists, &block)
end

#|(other) ⇒ Object

引数と自分自身とのORを取る

方法は和集合と同じ(#+参照)

other

計算をするSpriteList

返却値

変更を加えた自分自身の複製



469
470
471
 
# File 'lib/Miyako/API/sprite_list.rb', line 469

def |(other)
  self + other
end