Class: MiniGL::Sprite

Inherits:
Object
  • Object
show all
Defined in:
lib/minigl/game_object.rb

Overview

This class represents an (optionally animated) image inside the game screen.

Direct Known Subclasses

Effect, GameObject

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(x, y, img, sprite_cols = nil, sprite_rows = nil) ⇒ Sprite

Creates a new sprite.

Parameters:

x

The x-coordinate in the screen (or map) where the sprite will be drawn. This can be modified later via the x attribute.

y

The y-coordinate in the screen (or map) where the sprite will be drawn. This can be modified later via the y attribute.

img

The path to a PNG image or spritesheet, following the MiniGL convention: images must be inside a ‘data/img’ directory, relative to the code file, and you must only provide the file name, without extension, in this case. If the image is inside a subdirectory of ‘data/img’, you must prefix the file name with each subdirectory name, followed by an underscore (so the file and directories names must not contain underscores). For example, if your image is ‘data/img/sprite/1.png’, you must provide "sprite_1" or :sprite_1.

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.



35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/minigl/game_object.rb', line 35

def initialize(x, y, img, sprite_cols = nil, sprite_rows = nil)
  @x = x; @y = y
  @img =
    if sprite_cols.nil?
      [Res.img(img)]
    else
      Res.imgs img, sprite_cols, sprite_rows
    end
  @anim_counter = 0
  @img_index = 0
  @index_index = 0
end

Instance Attribute Details

#img_index ⇒ Object (readonly)

The index of the current sprite in the spritesheet being drawn.



7
8
9
 
# File 'lib/minigl/game_object.rb', line 7

def img_index
  @img_index
end

#x ⇒ Object

The x-coordinate of the image in the screen.



10
11
12
 
# File 'lib/minigl/game_object.rb', line 10

def x
  @x
end

#y ⇒ Object

The y-coordinate of the image in the screen.



13
14
15
 
# File 'lib/minigl/game_object.rb', line 13

def y
  @y
end

Instance Method Details

#animate(indices, interval) ⇒ Object

Performs time checking to update the image index according to the sequence of indices and the interval.

Parameters:

indices

The sequence of image indices used in the animation. The indices are determined from left to right, and from top to bottom, inside the spritesheet. All indices must be in the interval 0..(sprite_cols * sprite_rows).

interval

The amount of frames between each change in the image index. A frame will usually represent 1/60 second (roughly 17 milliseconds).



59
60
61
62
63
64
65
66
67
 
# File 'lib/minigl/game_object.rb', line 59

def animate(indices, interval)
  @anim_counter += 1
  if @anim_counter >= interval
    @index_index += 1
    @index_index = 0 if @index_index == indices.length
    @img_index = indices[@index_index]
    @anim_counter = 0
  end
end

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

Draws the sprite in the screen

Parameters:

map

A Map object, relative to which the sprite will be drawn (the x and y coordinates of the sprite 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.



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/minigl/game_object.rb', line 103

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 - (map ? map.cam.x : 0) + @img[0].width * scale_x * 0.5,
                              @y - (map ? map.cam.y : 0) + @img[0].height * scale_y * 0.5,
                              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 - (map ? map.cam.x : 0) + (flip == :horiz ? scale_x * @img[0].width : 0),
                          @y - (map ? map.cam.y : 0) + (flip == :vert ? scale_y * @img[0].height : 0),
                          z_index, (flip == :horiz ? -scale_x : scale_x),
                          (flip == :vert ? -scale_y : scale_y), color
  end
end

#set_animation(index) ⇒ Object

Resets the animation timer and immediately changes the image index to the specified value.

Parameters:

index

The image index to be set.



74
75
76
77
78
 
# File 'lib/minigl/game_object.rb', line 74

def set_animation(index)
  @anim_counter = 0
  @img_index = index
  @index_index = 0
end

#visible?(map = nil) ⇒ Boolean

Returns whether this sprite 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 sprite is visible on the screen.

Returns:

  • (Boolean) 


132
133
134
135
136
 
# File 'lib/minigl/game_object.rb', line 132

def visible?(map = nil)
  r = Rectangle.new @x, @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