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, #ow, #ox, #oy, #part_rect, #rect, #render_xy, #render_xy_to, #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
 
# File 'lib/Miyako/API/sprite_list.rb', line 158

def initialize(pairs = nil)
  @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

返却値

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



459
460
461
 
# File 'lib/Miyako/API/sprite_list.rb', line 459

def &(other)
  self * other
end

#*(other) ⇒ Object

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

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

other

計算をするSpriteList

返却値

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



439
440
441
442
443
 
# File 'lib/Miyako/API/sprite_list.rb', line 439

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

返却値

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



428
429
430
431
432
 
# File 'lib/Miyako/API/sprite_list.rb', line 428

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

#-(other) ⇒ Object

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

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

other

計算をするSpriteList

返却値

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



449
450
451
452
453
 
# File 'lib/Miyako/API/sprite_list.rb', line 449

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

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

返却値

追加した自分自身を渡す



419
420
421
 
# File 'lib/Miyako/API/sprite_list.rb', line 419

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

#==(other) ⇒ Object

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

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

other

比較元SpriteList

返却値

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



475
476
477
 
# File 'lib/Miyako/API/sprite_list.rb', line 475

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

名前

返却値

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



853
854
855
856
 
# File 'lib/Miyako/API/sprite_list.rb', line 853

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

スプライト

返却値

登録された自分自身



869
870
871
872
873
 
# File 'lib/Miyako/API/sprite_list.rb', line 869

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

スプライト本体

返却値

追加した自分自身を渡す



485
486
487
 
# File 'lib/Miyako/API/sprite_list.rb', line 485

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

#all ⇒ Object

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

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

返却値

スプライト名配列



266
267
268
 
# File 'lib/Miyako/API/sprite_list.rb', line 266

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

#assoc(name) ⇒ Object

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

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

name

検索対象のスプライト名

返却値

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



369
370
371
 
# File 'lib/Miyako/API/sprite_list.rb', line 369

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

#clear ⇒ Object

リストの中身を消去する

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



1009
1010
1011
 
# File 'lib/Miyako/API/sprite_list.rb', line 1009

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(ただしブロックを渡すと配列)



783
784
785
 
# File 'lib/Miyako/API/sprite_list.rb', line 783

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))
返却値

自分自身を返す



688
689
690
691
 
# File 'lib/Miyako/API/sprite_list.rb', line 688

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



720
721
722
723
 
# File 'lib/Miyako/API/sprite_list.rb', line 720

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



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

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



621
622
623
 
# File 'lib/Miyako/API/sprite_list.rb', line 621

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



633
634
635
636
637
 
# File 'lib/Miyako/API/sprite_list.rb', line 633

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



661
662
663
664
 
# File 'lib/Miyako/API/sprite_list.rb', line 661

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

#dispose ⇒ Object

オブジェクトを解放する



1014
1015
1016
1017
 
# File 'lib/Miyako/API/sprite_list.rb', line 1014

def dispose
  @list.clear
  @list = nil
end

#each ⇒ Object

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

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

返却値

自分自身を帰す



222
223
224
225
 
# File 'lib/Miyako/API/sprite_list.rb', line 222

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

#each_index ⇒ Object

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

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

返却値

自分自身を帰す



258
259
260
261
 
# File 'lib/Miyako/API/sprite_list.rb', line 258

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

#each_name ⇒ Object

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

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

返却値

自分自身を帰す



240
241
242
243
 
# File 'lib/Miyako/API/sprite_list.rb', line 240

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

#each_pair ⇒ Object

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

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

返却値

自分自身を帰す



231
232
233
234
 
# File 'lib/Miyako/API/sprite_list.rb', line 231

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

#each_value ⇒ Object

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

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

返却値

自分自身を帰す



249
250
251
252
 
# File 'lib/Miyako/API/sprite_list.rb', line 249

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) 


294
295
296
 
# File 'lib/Miyako/API/sprite_list.rb', line 294

def empty?
  @list.empty?
end

#eql?(other) ⇒ Boolean

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

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

返却値

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

Returns:

  • (Boolean) 


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

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) 


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

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



397
398
399
400
401
 
# File 'lib/Miyako/API/sprite_list.rb', line 397

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) 


318
319
320
 
# File 'lib/Miyako/API/sprite_list.rb', line 318

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

#has_name?(name) ⇒ Boolean

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

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

name

検索対象の名前

返却値

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

Returns:

  • (Boolean) 


327
328
329
 
# File 'lib/Miyako/API/sprite_list.rb', line 327

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

#has_value?(value) ⇒ Boolean

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

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

value

検索対象のスプライト

返却値

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

Returns:

  • (Boolean) 


344
345
346
 
# File 'lib/Miyako/API/sprite_list.rb', line 344

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

#hide(*params) ⇒ Object

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

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

params

表示対象に名前リスト。



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

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

表示対象に名前リスト。



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

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) 


336
337
338
 
# File 'lib/Miyako/API/sprite_list.rb', line 336

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

#index(name) ⇒ Object

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

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

name

検索対象のスプライト名

返却値

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



388
389
390
 
# File 'lib/Miyako/API/sprite_list.rb', line 388

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

#initialize_copy(obj) ⇒ Object

:nodoc:



183
184
185
186
187
 
# File 'lib/Miyako/API/sprite_list.rb', line 183

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:



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

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:



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

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



408
409
410
411
412
 
# File 'lib/Miyako/API/sprite_list.rb', line 408

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

#length ⇒ Object

リストの長さを求める

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

返却値

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



352
353
354
 
# File 'lib/Miyako/API/sprite_list.rb', line 352

def length
  @list.length
end

#merge(other) ⇒ Object

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

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

other

マージするSpriteList

返却値

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



698
699
700
701
702
 
# File 'lib/Miyako/API/sprite_list.rb', line 698

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

返却値

変更された自分自身



709
710
711
712
713
 
# File 'lib/Miyako/API/sprite_list.rb', line 709

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方向)。単位はピクセル

返却値

自分自身を返す



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

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方向)。単位はピクセル

返却値

自分自身を返す



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

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



379
380
381
 
# File 'lib/Miyako/API/sprite_list.rb', line 379

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

#names ⇒ Object

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

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

返却値

スプライト名配列



273
274
275
 
# File 'lib/Miyako/API/sprite_list.rb', line 273

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

#pairs ⇒ Object

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

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

返却値

ListPair構造体の配列



287
288
289
 
# File 'lib/Miyako/API/sprite_list.rb', line 287

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



884
885
886
 
# File 'lib/Miyako/API/sprite_list.rb', line 884

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(ただしブロックを渡すと配列)



803
804
805
 
# File 'lib/Miyako/API/sprite_list.rb', line 803

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の複製を返す



1154
1155
1156
1157
 
# File 'lib/Miyako/API/sprite_list.rb', line 1154

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

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

返却値：自分自身を返す



1167
1168
1169
1170
 
# File 'lib/Miyako/API/sprite_list.rb', line 1167

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

#pop ⇒ Object

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

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

返却値

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



511
512
513
514
 
# File 'lib/Miyako/API/sprite_list.rb', line 511

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

#push(*pairs) ⇒ Object

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

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

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

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

返却値

追加した自分自身を渡す



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

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



647
648
649
650
651
 
# File 'lib/Miyako/API/sprite_list.rb', line 647

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



674
675
676
677
 
# File 'lib/Miyako/API/sprite_list.rb', line 674

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

#render ⇒ Object

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

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

返却値

自分自身を帰す



1334
1335
1336
1337
1338
 
# File 'lib/Miyako/API/sprite_list.rb', line 1334

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

#render_to(dst) ⇒ Object

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

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

dst

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

返却値

自分自身を帰す



1344
1345
1346
1347
1348
 
# File 'lib/Miyako/API/sprite_list.rb', line 1344

def render_to(dst)
  return self unless @visible
  self.sprite_only.each{|pair| pair[1].render_to(dst) }
  return self
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

返却値

置き換えた自分自身



817
818
819
820
821
 
# File 'lib/Miyako/API/sprite_list.rb', line 817

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

#reset ⇒ Object

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

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

返却値

自分自身を返す



1319
1320
1321
1322
 
# File 'lib/Miyako/API/sprite_list.rb', line 1319

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))
返却値

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



830
831
832
833
 
# File 'lib/Miyako/API/sprite_list.rb', line 830

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))
返却値

自分自身を帰す



841
842
843
844
 
# File 'lib/Miyako/API/sprite_list.rb', line 841

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を配列化したもの



767
768
769
 
# File 'lib/Miyako/API/sprite_list.rb', line 767

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



580
581
582
583
584
 
# File 'lib/Miyako/API/sprite_list.rb', line 580

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

表示対象に名前リスト。



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

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

表示対象に名前リスト。



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

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))
返却値

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



734
735
736
 
# File 'lib/Miyako/API/sprite_list.rb', line 734

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))
返却値

シャッフルした自分自身



746
747
748
749
 
# File 'lib/Miyako/API/sprite_list.rb', line 746

def shuffle!
  @list.shuffle!
  self
end

#size ⇒ Object

リストの長さを求める

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

返却値

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



360
361
362
 
# File 'lib/Miyako/API/sprite_list.rb', line 360

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

スプライト名のリスト

返却値

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



539
540
541
542
 
# File 'lib/Miyako/API/sprite_list.rb', line 539

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

スプライト名のリスト

返却値

更新した自分自身



555
556
557
 
# File 'lib/Miyako/API/sprite_list.rb', line 555

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

#sprite_only ⇒ Object

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

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

返却値

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



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

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していない対を削除する。

返却値

自分自身を帰す



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

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メソッドを呼び出す

返却値

自分自身を返す



1303
1304
1305
1306
 
# File 'lib/Miyako/API/sprite_list.rb', line 1303

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

#stop ⇒ Object

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

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

返却値

自分自身を返す



1311
1312
1313
1314
 
# File 'lib/Miyako/API/sprite_list.rb', line 1311

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:



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

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)]
返却値

生成した配列



984
985
986
 
# File 'lib/Miyako/API/sprite_list.rb', line 984

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)]
返却値

生成した配列



994
995
996
 
# File 'lib/Miyako/API/sprite_list.rb', line 994

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の複製を返す



1113
1114
1115
1116
 
# File 'lib/Miyako/API/sprite_list.rb', line 1113

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

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

返却値：自分自身を返す



1126
1127
1128
1129
 
# File 'lib/Miyako/API/sprite_list.rb', line 1126

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)}
返却値

生成したハッシュ



1003
1004
1005
 
# File 'lib/Miyako/API/sprite_list.rb', line 1003

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の複製を返す



1180
1181
1182
1183
 
# File 'lib/Miyako/API/sprite_list.rb', line 1180

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

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

返却値：自分自身を返す



1193
1194
1195
1196
 
# File 'lib/Miyako/API/sprite_list.rb', line 1193

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

#to_s ⇒ Object

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

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

返却値

変換した文字列



1354
1355
1356
 
# File 'lib/Miyako/API/sprite_list.rb', line 1354

def to_s
  self.to_a.to_s
end

#unshift(name, sprite) ⇒ Object

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

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

name

スプライト名

sprite

スプライト本体

返却値

追加した自分自身を渡す



522
523
524
525
526
 
# File 'lib/Miyako/API/sprite_list.rb', line 522

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メソッドを呼び出した結果を配列で返す



1327
1328
1329
 
# File 'lib/Miyako/API/sprite_list.rb', line 1327

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

#values ⇒ Object

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

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

返却値

スプライト本体配列



280
281
282
 
# File 'lib/Miyako/API/sprite_list.rb', line 280

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

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

返却値

生成された配列



897
898
899
 
# File 'lib/Miyako/API/sprite_list.rb', line 897

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



915
916
917
918
 
# File 'lib/Miyako/API/sprite_list.rb', line 915

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

#|(other) ⇒ Object

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

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

other

計算をするSpriteList

返却値

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



467
468
469
 
# File 'lib/Miyako/API/sprite_list.rb', line 467

def |(other)
  self + other
end