Class: AdventureRL::Mask

Inherits:
Point
  • Object
show all
Includes:
Helpers::MethodHelper
Defined in:
lib/AdventureRL/Mask.rb

Overview

The Mask is basically a bounding box or rectangle. It has a position (Point) and a size.

Direct Known Subclasses

Image, Layer, Quadtree, Rectangle

Constant Summary collapse

MASKS =

This array will be filled with any created Masks. Just so they won’t get garbage collected (not sure how garbage collection works).

[]
DEFAULT_SETTINGS =

Default settings for Mask. Are superseded by settings passed to #initialize.

Settings.new({
  position: {
    x: 0,
    y: 0
  },
  size: {
    width:  64,
    height: 64
  },
  origin: {
    x: :left,
    y: :top
  },
  assign_to: nil
})

Constants inherited from Point

Point::POINTS

Instance Method Summary collapse

Methods inherited from Point

#get_point, #get_position, #get_real_point, #get_real_position, #has_point?, #keys, #move_by, #set_position, #values, #x, #y

Constructor Details

#initialize(settings_arg = {}) ⇒ Mask

Pass settings Hash or AdventureRL::Settings as argument. Supersedes DEFAULT_SETTINGS.



32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/AdventureRL/Mask.rb', line 32

def initialize settings_arg = {}
  MASKS << self
  settings = DEFAULT_SETTINGS.merge settings_arg
  super *settings.get(:position).values
  @size             = settings.get(:size)
  @origin           = settings.get(:origin)
  @assigned_to    = []
  assign_to settings.get(:assign_to)  if (settings.get(:assign_to))
  @layer            = nil
  call_setup_method settings_arg
end

Instance Method Details

#assign_to(object) ⇒ Object

Assign this Mask to an instance. This will make all Mask methods available as a fallback on the instance itself. This also gives the possibility to define event methods on the object.



49
50
51
52
 
# File 'lib/AdventureRL/Mask.rb', line 49

def assign_to object
  Helpers::PipeMethods.pipe_methods_from object, to: self
  @assigned_to << object
end

#assigned_to?(object) ⇒ Boolean

Returns true if the Mask has been assigned to the passed object.

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/AdventureRL/Mask.rb', line 61

def assigned_to? object
  return @assigned_to.include? object
end

#collides_with?(other) ⇒ Boolean

Returns true if this Mask collides with other …

  • Mask,

  • Point,

  • or Hash with keys :x and :y.

Returns:

  • (Boolean) 


258
259
260
261
262
 
# File 'lib/AdventureRL/Mask.rb', line 258

def collides_with? other
  return collides_with_mask?  other  if (other.has_mask?  rescue false)
  return collides_with_point? other  if (other.has_point? rescue false)
  return collides_with_hash?  other  if (other.is_a?(Hash))
end

#collides_with_hash?(hash) ⇒ Boolean

Returns true if this Mask collides with other Hash.

Returns:

  • (Boolean) 


308
309
310
311
312
313
314
 
# File 'lib/AdventureRL/Mask.rb', line 308

def collides_with_hash? hash
  if (hash.keys.include_all?(:x, :y))
    point = Point.new hash[:x], hash[:y]
    return collides_with_point? point
  end
  return nil
end

#collides_with_mask?(mask, checked = false) ⇒ Boolean

Returns true if this Mask collides with other Mask.

Returns:

  • (Boolean) 


265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/AdventureRL/Mask.rb', line 265

def collides_with_mask? mask, checked = false
  this_sides  = get_real_sides
  other_sides = mask.get_real_sides
  return (
    (
      (
        other_sides[:left] >= this_sides[:left] &&
        other_sides[:left] <= this_sides[:right]
      ) || (
        other_sides[:right] >= this_sides[:left] &&
        other_sides[:right] <= this_sides[:right]
      ) || (
        other_sides[:left]  <= this_sides[:left] &&
        other_sides[:right] >= this_sides[:right]
      )
    ) && (
      (
        other_sides[:top] >= this_sides[:top] &&
        other_sides[:top] <= this_sides[:bottom]
      ) || (
        other_sides[:bottom] >= this_sides[:top] &&
        other_sides[:bottom] <= this_sides[:bottom]
      ) || (
        other_sides[:top]    <= this_sides[:top] &&
        other_sides[:bottom] >= this_sides[:bottom]
      )
    )
  ) || (!checked && mask.collides_with_mask?(self, true))
end

#collides_with_point?(point) ⇒ Boolean

Returns true if this Mask collides with other Point.

Returns:

  • (Boolean) 


296
297
298
299
300
301
302
303
304
305
 
# File 'lib/AdventureRL/Mask.rb', line 296

def collides_with_point? point
  real_point = point.get_real_point
  real_sides = get_real_sides
  return (
    real_point.x >= real_sides[:left]  &&
    real_point.x <= real_sides[:right] &&
    real_point.y >= real_sides[:top]   &&
    real_point.y <= real_sides[:bottom]
  )
end

#get_assigned ⇒ Object

Returns all objects this Mask was assigned to.



55
56
57
 
# File 'lib/AdventureRL/Mask.rb', line 55

def get_assigned
  return @assigned_to
end

#get_center(target = :all) ⇒ Object

Returns the center Point of the Mask. An optional target argument can be passed, which can either be an axis (:x or :y), or :all, which returns a Hash with both values.



228
229
230
231
232
233
234
235
236
 
# File 'lib/AdventureRL/Mask.rb', line 228

def get_center target = :all
  target = target.to_sym
  return Point.new(
    get_center_x,
    get_center_y
  )  if (target == :all)
  return method("get_center_#{target.to_s}".to_sym).call  if (get_point.keys.include? target)
  return nil
end

#get_corner(side_x, side_y) ⇒ Object

Returns a Point with the position of a specific corner. Takes two mandatory arguments:

side_x

Either :left or :right.

side_y

Either :top or :bottom.



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/AdventureRL/Mask.rb', line 174

def get_corner side_x, side_y
  side_x = side_x.to_sym
  side_y = side_y.to_sym
  return Point.new(
    get_side(side_x),
    get_side(side_y)
  )  unless ([side_x, side_y].include? :center)
  if    (side_x == side_y)
    center = get_center.values
    return Point.new(*center)
  elsif (side_x == :center)
    return Point.new(
      get_center(:x),
      get_side(side_y)
    )
  elsif (side_y == :center)
    return Point.new(
      get_side(side_x),
      get_center(:y)
    )
  end
  return nil
end

#get_layer ⇒ Object

Returns the parent Layer.



326
327
328
 
# File 'lib/AdventureRL/Mask.rb', line 326

def get_layer
  return @layer
end

#get_mask ⇒ Object

Returns self. Used to get an instance’s mask when it has been assigned to it.



67
68
69
 
# File 'lib/AdventureRL/Mask.rb', line 67

def get_mask
  return self
end

#get_origin(target = :all) ⇒ Object

Returns the set origin. Can pass an optional target argument, which can be either an axis (:x or :y), or :all, which returns a Hash with both values.



103
104
105
106
107
108
 
# File 'lib/AdventureRL/Mask.rb', line 103

def get_origin target = :all
  target = target.to_sym
  return @origin          if (target == :all)
  return @origin[target]  if (@origin.key?(target))
  return nil
end

#get_real_center(target = :all) ⇒ Object

Returns the real window position of this center. See #get_center for usage.



240
241
242
243
244
245
246
247
248
249
250
251
252
 
# File 'lib/AdventureRL/Mask.rb', line 240

def get_real_center target = :all
  scale = get_scale
  side = :left  if (target == :x)
  side = :top   if (target == :y)
  return Point.new(
    (get_real_side(:left) + (get_center_x * scale[:x])),
    (get_real_side(:top)  + (get_center_y * scale[:y]))
  )  if (target == :all)
  return (
    get_real_side(side) + (method("get_center_#{target.to_s}".to_sym).call * scale[target])
  )  if (get_point.keys.include? target)
  return nil
end

#get_real_corner(side_x, side_y) ⇒ Object

Returns the real window position of the corner. See #get_corner for usage.



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/AdventureRL/Mask.rb', line 200

def get_real_corner side_x, side_y
  side_x = side_x.to_sym
  side_y = side_y.to_sym
  return Point.new(
    get_real_side(side_x),
    get_real_side(side_y)
  )  unless ([side_x, side_y].include? :center)
  if    (side_x == side_y)
    center = get_real_center.values
    return Point.new(*center)
  elsif (side_x == :center)
    return Point.new(
      get_real_center(:x),
      get_real_side(side_y)
    )
  elsif (side_y == :center)
    return Point.new(
      get_real_side(side_x),
      get_real_center(:y)
    )
  end
  return nil
end

#get_real_side(side) ⇒ Object

Returns the real window position of side. See #get_side for usage.



135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/AdventureRL/Mask.rb', line 135

def get_real_side side
  axis = :x  if ([:left, :right].include? side)
  axis = :y  if ([:top, :bottom].include? side)
  side_pos  = get_side(side) * get_scale(axis)
  return side_pos  unless (has_layer?)
  case side
  when :left, :right
    return get_layer.get_real_side(:left) + side_pos
  when :top, :bottom
    return get_layer.get_real_side(:top) + side_pos
  else
    return nil
  end
end

#get_real_sides ⇒ Object

Returns the real window positions of all four sides.



161
162
163
164
165
166
167
168
 
# File 'lib/AdventureRL/Mask.rb', line 161

def get_real_sides
  return {
    left:   get_real_side(:left),
    right:  get_real_side(:right),
    top:    get_real_side(:top),
    bottom: get_real_side(:bottom)
  }
end

#get_side(side) ⇒ Object

Returns the position Integer of a specific side. Takes one mandatory argument, side, which can be one of the following:

:left or :right

Returns the x position of the left or right side/border, respectively.

:top or :bottom

Returns the y position of the top or bottom side/border, respectively.



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/AdventureRL/Mask.rb', line 117

def get_side side
  side = side.to_sym
  case side
  when :left
    return get_side_left
  when :right
    return get_side_right
  when :top
    return get_side_top
  when :bottom
    return get_side_bottom
  else
    return nil
  end
end

#get_sides ⇒ Object

Returns the positions of all four sides.



151
152
153
154
155
156
157
158
 
# File 'lib/AdventureRL/Mask.rb', line 151

def get_sides
  return {
    left:   get_side(:left),
    right:  get_side(:right),
    top:    get_side(:top),
    bottom: get_side(:bottom)
  }
end

#get_size(target = :all) ⇒ Object

Returns the size of the Mask. Can pass an optional target argument, which can be either an axis (:width or :height), or :all, which returns a Hash with both values.



81
82
83
84
85
86
 
# File 'lib/AdventureRL/Mask.rb', line 81

def get_size target = :all
  target = target.to_sym
  return @size          if (target == :all)
  return @size[target]  if (@size.key?(target))
  return nil
end

#has_layer? ⇒ Boolean

Returns true if this Mask has a parent Layer.

Returns:

  • (Boolean) 


331
332
333
 
# File 'lib/AdventureRL/Mask.rb', line 331

def has_layer?
  return !!@layer
end

#has_mask? ⇒ Boolean

Returns true. Used to verify if an instance has a Mask assigned to it.

Returns:

  • (Boolean) 


73
74
75
 
# File 'lib/AdventureRL/Mask.rb', line 73

def has_mask?
  return true
end

#set_layer(layer) ⇒ Object

Set the parent Layer.



317
318
319
320
321
322
323
 
# File 'lib/AdventureRL/Mask.rb', line 317

def set_layer layer
  error(
    "Passed argument `layer' must be an instance of `Layer', but got",
    "`#{layer.inspect}:#{layer.class.name}'."
  )  unless (layer.is_a? Layer)
  @layer = layer
end

#set_size(*args) ⇒ Object Also known as: resize

Set a new Mask size. args are very similar to Point#set_position, only that the axes (:x and :y) are replaced with :width and :height.



92
93
94
95
96
 
# File 'lib/AdventureRL/Mask.rb', line 92

def set_size *args
  new_size = parse_size(*args)
  @size[:width]  = new_size[:width]   if (new_size.key? :width)
  @size[:height] = new_size[:height]  if (new_size.key? :height)
end