Class: MiniGL::GameObject

Inherits:

Sprite

• Object
• Sprite
• MiniGL::GameObject

Includes:

Movement

Defined in:

lib/minigl/game_object.rb

Overview

This class represents an object with a set of properties and methods commonly used in games. It defines an object with a rectangular bounding box, and having all the attributes required for using the Movement module.

Instance Attribute Summary

Attributes included from Movement

#bottom, #h, #left, #mass, #max_speed, #passable, #prev_speed, #right, #speed, #stored_forces, #top, #w, #x, #y

Attributes inherited from Sprite

#img_index, #x, #y

Instance Method Summary

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

  Draws the game object in the screen.

• #initialize(x, y, w, h, img, img_gap = nil, sprite_cols = nil, sprite_rows = nil, mass = 1.0) ⇒ GameObject constructor

  Creates a new game object.

• #visible?(map = nil) ⇒ Boolean

  Returns whether this object is visible in the given map (i.e., in the viewport determined by the camera of the given map).

Methods included from Movement

#bounds, #cycle, #move, #move_carrying, #move_free

Methods inherited from Sprite

#animate, #set_animation

Constructor Details

#initialize(x, y, w, h, img, img_gap = nil, sprite_cols = nil, sprite_rows = nil, mass = 1.0) ⇒ GameObject

Creates a new game object.

Parameters:

x

The x-coordinate of the object’s bounding box. This can be modified later via the x attribute.

y

The y-coordinate of the object’s bounding box. This can be modified later via the y attribute.

w

The width of the object’s bounding box.

h

The height of the object’s bounding box.

img

The image or spritesheet for the object.

img_gap

A Vector object representing the difference between the top left corner of the bounding box and the coordinates of the image. For example, an object with x = 100, y = 50 and img_gap = Vector.new(-5, -5) will be drawn at position (95, 45) of the screen.

sprite_cols

The number of columns in the spritesheet. Use nil if the image is not a spritesheet.

sprite_rows

The number of rows in the spritesheet. Use nil if the image is not a spritesheet.

mass

The mass of the object. Details on how it is used can be found in the Movement module.

# File 'lib/minigl/game_object.rb', line 166

def initialize(x, y, w, h, img, img_gap = nil, sprite_cols = nil, sprite_rows = nil, mass = 1.0)
  super x, y, img, sprite_cols, sprite_rows
  @w = w; @h = h
  @img_gap =
    if img_gap.nil?
      Vector.new 0, 0
    else
      img_gap
    end
  @mass = mass
  @speed = Vector.new 0, 0
  @max_speed = Vector.new 15, 15
  @stored_forces = Vector.new 0, 0
end

Instance Method Details

#draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0) ⇒ 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.

Obs.: This method accepts named parameters.

# File 'lib/minigl/game_object.rb', line 204

def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0)
  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)
    map = map.fetch(:map, nil)
  end

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

#visible?(map = nil) ⇒ Boolean

Returns whether this object is visible in the given map (i.e., in the viewport determined by the camera of the given map). If no map is given, returns whether the object is visible on the screen.

Returns:

• (Boolean)

# File 'lib/minigl/game_object.rb', line 233

def visible?(map = nil)
  r = Rectangle.new @x.round + @img_gap.x, @y.round + @img_gap.y, @img[0].width, @img[0].height
  return Rectangle.new(0, 0, G.window.width, G.window.height).intersect? r if map.nil?
  map.cam.intersect? r
end