Method: MiniGL::GameObject#draw

Defined in:
lib/minigl/game_object.rb

#draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0, round = false) ⇒ Object

Draws the game object in the screen.

Parameters:

map

A Map object, relative to which the object will be drawn (the x and y coordinates of the image will be changed according to the position of the camera).

scale_x

A scale factor to be applied horizontally to the image.

scale_y

A scale factor to be applied vertically to the image.

alpha

The opacity with which the image will be drawn. Valid values vary from 0 (fully transparent) to 255 (fully opaque).

color

A color filter to apply to the image. A white (0xffffff) filter will keep all colors unchanged, while a black (0x000000) filter will turn all colors to black. A red (0xff0000) filter will keep reddish colors with slight or no change, whereas bluish colors will be darkened, for example.

angle

A rotation, in degrees, to be applied to the image, relative to its center.

flip

Specify :horiz to draw the image horizontally flipped or :vert to draw it vertically flipped.

z_index

The z-order to draw the object. Objects with larger z-orders will be drawn on top of the ones with smaller z-orders.

round

Specify whether the drawing coordinates should be rounded to an integer before drawing, to avoid little distortions of the image. Only applies when the image is not rotated.

Obs.: This method accepts named parameters.



254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/minigl/game_object.rb', line 254

def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0, round = false)
  if map.is_a? Hash
    scale_x = map.fetch(:scale_x, 1)
    scale_y = map.fetch(:scale_y, 1)
    alpha = map.fetch(:alpha, 0xff)
    color = map.fetch(:color, 0xffffff)
    angle = map.fetch(:angle, nil)
    flip = map.fetch(:flip, nil)
    z_index = map.fetch(:z_index, 0)
    round = map.fetch(:round, false)
    map = map.fetch(:map, nil)
  end

  color = (alpha << 24) | color
  if angle
    center_x = @x + @w * 0.5
    center_y = @y + @h * 0.5
    o_x = center_x - @x - @img_gap.x
    o_y = center_y - @y - @img_gap.y
    @img[@img_index].draw_rot @x + (flip == :horiz ? -1 : 1) * (@img_gap.x + o_x) - (map ? map.cam.x : 0),
                              @y + (flip == :vert ? -1 : 1) * (@img_gap.y + o_y) - (map ? map.cam.y : 0),
                              z_index, angle, o_x.to_f / (@img[0].width * scale_x), o_y.to_f / (@img[0].height * scale_y),
                              (flip == :horiz ? -scale_x : scale_x), (flip == :vert ? -scale_y : scale_y), color
  else
    x = @x + (flip == :horiz ? -1 : 1) * @img_gap.x - (map ? map.cam.x : 0) + (flip == :horiz ? @w : 0)
    y = @y + (flip == :vert ? -1 : 1) * @img_gap.y - (map ? map.cam.y : 0) + (flip == :vert ? @h : 0)
    @img[@img_index].draw (round ? x.round : x), (round ? y.round : y),
                          z_index, (flip == :horiz ? -scale_x : scale_x),
                          (flip == :vert ? -scale_y : scale_y), color
  end
end