Class: Smalruby::Character

Inherits:
Sprite
  • Object
show all
Extended by:
Forwardable, Mutex_m
Defined in:
lib/smalruby/character.rb

Overview

キャラクターを表現するクラス

Direct Known Subclasses

Canvas, Console

Instance Attribute Summary collapse

動き collapse

見た目 collapse

調べる collapse

音 collapse

ハードウェア collapse

Instance Method Summary collapse

Constructor Details

#initialize(option = {}) ⇒ Character

Returns a new instance of Character.



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/smalruby/character.rb', line 22

def initialize(option = {})
  defaults = {
    x: 0,
    y: 0,
    costume: nil,
    angle: 0,
    visible: true
  }
  opt = process_optional_arguments(option, defaults)

  # TODO: コスチュームの配列に対応する
  if opt[:costume].is_a?(String)
    opt[:costume] = Image.load(asset_path(opt[:costume]))
  end
  super(opt[:x], opt[:y], opt[:costume])

  @event_handlers = {}
  @threads = []
  @checking_hit_targets = []

  self.scale_x = 1.0
  self.scale_y = 1.0
  @vector = { x: 1, y: 0 }

  [:visible].each do |k|
    if opt.key?(k)
      send("#{k}=", opt[k])
    end
  end

  if opt[:angle] != 0
    rotate(opt[:angle])
  end

  World.instance.objects << self
end

Instance Attribute Details

#checking_hit_targets ⇒ Object

Returns the value of attribute checking_hit_targets.



20
21
22
 
# File 'lib/smalruby/character.rb', line 20

def checking_hit_targets
  @checking_hit_targets
end

#event_handlers ⇒ Object

Returns the value of attribute event_handlers.



18
19
20
 
# File 'lib/smalruby/character.rb', line 18

def event_handlers
  @event_handlers
end

#threads ⇒ Object

Returns the value of attribute threads.



19
20
21
 
# File 'lib/smalruby/character.rb', line 19

def threads
  @threads
end

Instance Method Details

#alive? ⇒ Boolean

Returns:

  • (Boolean) 


305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/smalruby/character.rb', line 305

def alive?
  @threads.delete_if { |t|
    if t.alive?
      false
    else
      begin
        t.join
      rescue => e
        Util.print_exception(e)
        exit(1)
      end
      true
    end
  }
  @threads.length > 0
end

#angle=(val) ⇒ Object

(　)度に向ける



90
91
92
93
94
95
96
 
# File 'lib/smalruby/character.rb', line 90

def angle=(val)
  val %= 360
  radian = val * Math::PI / 180
  @vector[:x] = self.scale_x * Math.cos(radian)
  @vector[:y] = self.scale_x * Math.sin(radian)
  super(val)
end

#click(buttons) ⇒ Object 



276
277
278
279
280
281
282
283
 
# File 'lib/smalruby/character.rb', line 276

def click(buttons)
  @event_handlers[:click].try(:each) do |h|
    if h.options.length > 0 && !h.options.any? { |b| buttons.include?(b) }
      next
    end
    @threads << h.call(Input.mouse_pos_x, Input.mouse_pos_y)
  end
end

#distance(x, y) ⇒ Object

距離



162
163
164
165
 
# File 'lib/smalruby/character.rb', line 162

def distance(x, y)
  Math.sqrt((self.x + center_x - x).abs**2 +
            (self.y + center_y - y).abs**2).to_i
end

#draw ⇒ Object 



218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/smalruby/character.rb', line 218

def draw
  draw_balloon

  if self.x < 0
    self.x = 0
  elsif self.x + image.width >= Window.width
    self.x = Window.width - image.width
  end
  if self.y < 0
    self.y = 0
  elsif self.y + image.height >= Window.height
    self.y = Window.height - image.height
  end
  super
end

#hit ⇒ Object 



285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/smalruby/character.rb', line 285

def hit
  # TODO: なんでもいいからキャラクターに当たった場合に対応する
  @checking_hit_targets &= World.instance.objects
  objects = check(@checking_hit_targets)
  return if objects.empty?
  @event_handlers[:hit].try(:each) do |h|
    if h.options.length > 0 && !h.options.any? { |o| objects.include?(o) }
      next
    end
    @threads << h.call(h.options & objects)
  end
end

#hit?(other) ⇒ Boolean

Returns:

  • (Boolean) 


173
174
175
 
# File 'lib/smalruby/character.rb', line 173

def hit?(other)
  check([other]).length > 0
end

#join ⇒ Object 



322
323
324
 
# File 'lib/smalruby/character.rb', line 322

def join
  @threads.each(&:join)
end

#key_down(keys) ⇒ Object 



258
259
260
261
262
263
264
265
 
# File 'lib/smalruby/character.rb', line 258

def key_down(keys)
  @event_handlers[:key_down].try(:each) do |h|
    if h.options.length > 0 && !h.options.any? { |k| keys.include?(k) }
      next
    end
    @threads << h.call
  end
end

#key_push(keys) ⇒ Object 



267
268
269
270
271
272
273
274
 
# File 'lib/smalruby/character.rb', line 267

def key_push(keys)
  @event_handlers[:key_push].try(:each) do |h|
    if h.options.length > 0 && !h.options.any? { |k| keys.include?(k) }
      next
    end
    @threads << h.call
  end
end

#led(pin) ⇒ Object

LED



197
198
199
 
# File 'lib/smalruby/character.rb', line 197

def led(pin)
  Hardware.create_hardware(Hardware::Led, pin)
end

#loop(&block) ⇒ Object 



326
327
328
329
330
331
 
# File 'lib/smalruby/character.rb', line 326

def loop(&block)
  Kernel.loop do
    yield
    Smalruby.await
  end
end

#move(val = 1) ⇒ Object

( )歩動かす



62
63
64
65
 
# File 'lib/smalruby/character.rb', line 62

def move(val = 1)
  self.x += @vector[:x] * val
  self.y += @vector[:y] * val
end

#move_back(val = 1) ⇒ Object

( )歩後ろに動かす



68
69
70
 
# File 'lib/smalruby/character.rb', line 68

def move_back(val = 1)
  move(-val)
end

#on(event, *options, &block) ⇒ Object 



234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/smalruby/character.rb', line 234

def on(event, *options, &block)
  event = event.to_sym
  @event_handlers[event] ||= []
  h = EventHandler.new(self, options, &block)
  @event_handlers[event] << h

  case event
  when :start
    @threads << h.call if Smalruby.started?
  when :hit
    @checking_hit_targets << options
    @checking_hit_targets.flatten!
    @checking_hit_targets.uniq!
  when :sensor_change
    sensor(options.first)
  end
end

#play(option = {}) ⇒ Object 



181
182
183
184
185
186
187
188
189
190
 
# File 'lib/smalruby/character.rb', line 181

def play(option = {})
  defaults = {
    name: 'piano_do.wav'
  }
  opt = process_optional_arguments(option, defaults)

  @sound_cache ||= {}
  (@sound_cache[opt[:name]] ||= Sound.new(asset_path(opt[:name])))
    .play
end

#point_towards(target) ⇒ Object

( )に向ける



99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/smalruby/character.rb', line 99

def point_towards(target)
  if target == :mouse
    tx = Input.mouse_pos_x
    ty = Input.mouse_pos_y
  else
    tx = target.x
    ty = target.y
  end
  dx = tx - x
  dy = ty - y
  self.angle = Math.atan2(dy, dx) * 180 / Math::PI
end

#reach_wall? ⇒ Boolean

端に着いた

Returns:

  • (Boolean) 


168
169
170
171
 
# File 'lib/smalruby/character.rb', line 168

def reach_wall?
  self.x < 0 || self.x >= (Window.width - image.width) ||
    self.y < 0 || self.y >= (Window.height - image.height)
end

#rgb_led_anode(pin) ⇒ Object

RGB LED(アノード)



202
203
204
 
# File 'lib/smalruby/character.rb', line 202

def rgb_led_anode(pin)
  Hardware.create_hardware(Hardware::RgbLedAnode, pin)
end

#rgb_led_cathode(pin) ⇒ Object

RGB LED(カソード)



207
208
209
 
# File 'lib/smalruby/character.rb', line 207

def rgb_led_cathode(pin)
  Hardware.create_hardware(Hardware::RgbLedCathode, pin)
end

#rotate(angle) ⇒ Object

( )度回転する



85
86
87
 
# File 'lib/smalruby/character.rb', line 85

def rotate(angle)
  self.angle += angle
end

#say(options = {}) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/smalruby/character.rb', line 116

def say(options = {})
  defaults = {
    message: '',
    second: 0,
  }
  opts = process_optional_arguments(options, defaults)

  if @balloon
    @balloon.vanish
    @balloon = nil
  end

  message = opts[:message].to_s
  return if message.empty?

  lines = message.to_s.lines.map { |l| l.scan(/.{1,10}/) }.flatten
  font = new_font(16)
  width = lines.map { |l| font.get_width(l) }.max
  height = lines.length * (font.size + 1)
  frame_size = 3
  margin_size = 3
  image = Image.new(width + (frame_size + margin_size) * 2,
                    height + (frame_size + margin_size) * 2)
  image.box_fill(0,
                 0,
                 width + (frame_size + margin_size) * 2 - 1,
                 height + (frame_size + margin_size) * 2 - 1,
                 [125, 125, 125])
  image.box_fill(frame_size,
                 frame_size,
                 width + (frame_size + margin_size) + margin_size - 1,
                 height + (frame_size + margin_size) + margin_size - 1,
                 [255, 255, 255])
  lines.each.with_index do |line, row|
    image.draw_font(frame_size + margin_size,
                    frame_size + margin_size + (font.size + 1) * row,
                    line, font, [0, 0, 0])
  end
  @balloon = Sprite.new(self.x, self.y, image)
end

#sensor(pin) ⇒ Object

汎用的なセンサー



212
213
214
 
# File 'lib/smalruby/character.rb', line 212

def sensor(pin)
  Hardware.create_hardware(Hardware::Sensor, pin)
end

#sensor_change(pin, value) ⇒ Object 



298
299
300
301
302
303
 
# File 'lib/smalruby/character.rb', line 298

def sensor_change(pin, value)
  @event_handlers[:sensor_change].try(:each) do |h|
    next unless h.options.include?(pin)
    @threads << h.call(value)
  end
end

#start ⇒ Object 



252
253
254
255
256
 
# File 'lib/smalruby/character.rb', line 252

def start
  @event_handlers[:start].try(:each) do |h|
    @threads << h.call
  end
end

#turn ⇒ Object

振り返る



73
74
75
76
77
 
# File 'lib/smalruby/character.rb', line 73

def turn
  @vector[:x] *= -1
  @vector[:y] *= -1
  self.scale_x *= -1
end

#turn_if_reach_wall ⇒ Object

もし端に着いたら、跳ね返る



80
81
82
 
# File 'lib/smalruby/character.rb', line 80

def turn_if_reach_wall
  turn if reach_wall?
end