minigl 1.3.10 → 2.0.0

data/lib/minigl/map.rb

@@ -1,12 +1,12 @@
 require_relative 'global'
 
-module AGL
+module MiniGL
   # This class provides easy control of a tile map, i.e., a map consisting of
   # a grid of equally sized tiles. It also provides viewport control, through
   # its camera property and methods.
   class Map
-    Sqrt2Div2 = Math.sqrt(2) / 2 # :nodoc:
-    MinusPiDiv4 = -Math::PI / 4 # :nodoc:
+    SQRT_2_DIV_2 = Math.sqrt(2) / 2 # :nodoc:
+    MINUS_PI_DIV_4 = -Math::PI / 4 # :nodoc:
 
     # A Vector where x is the tile width and y is the tile height.
     attr_reader :tile_size
@@ -34,7 +34,7 @@ module AGL
     #             outside the map to appear in the screen, the camera would
     #             move to the nearest position where only the map shows up
     #             in the screen).
-    def initialize t_w, t_h, t_x_count, t_y_count, scr_w = 800, scr_h = 600, isometric = false, limit_cam = true
+    def initialize(t_w, t_h, t_x_count, t_y_count, scr_w = 800, scr_h = 600, isometric = false, limit_cam = true)
       @tile_size = Vector.new t_w, t_h
       @size = Vector.new t_x_count, t_y_count
       @cam = Rectangle.new 0, 0, scr_w, scr_h
@@ -71,7 +71,7 @@ module AGL
     #         the interval <code>0..t_x_count</code>.
     # [map_y] The index of the tile in the vertical direction. It must be in
     #         the interval <code>0..t_y_count</code>.
-    def get_screen_pos map_x, map_y
+    def get_screen_pos(map_x, map_y)
       return Vector.new(map_x * @tile_size.x - @cam.x, map_y * @tile_size.y - @cam.y) unless @isometric
       Vector.new ((map_x - map_y - 1) * @tile_size.x * 0.5) - @cam.x + @x_offset,
                  ((map_x + map_y) * @tile_size.y * 0.5) - @cam.y
@@ -84,7 +84,7 @@ module AGL
     # Parameters:
     # [scr_x] The x-coordinate in the screen.
     # [scr_y] The y-coordinate in the screen.
-    def get_map_pos scr_x, scr_y
+    def get_map_pos(scr_x, scr_y)
       return Vector.new((scr_x + @cam.x) / @tile_size.x, (scr_y + @cam.y) / @tile_size.y) unless @isometric
 
       # Obtém a posição transformada para as coordenadas isométricas
@@ -99,7 +99,7 @@ module AGL
     # Parameters:
     # [v] A Vector representing the tile, with x as the horizontal index and
     #     y as the vertical index.
-    def is_in_map v
+    def is_in_map(v)
       v.x >= 0 && v.y >= 0 && v.x < @size.x && v.y < @size.y
     end
 
@@ -109,7 +109,7 @@ module AGL
     # Parameters:
     # [cam_x] The x-coordinate inside the map, in pixels (not a tile index).
     # [cam_y] The y-coordinate inside the map, in pixels (not a tile index).
-    def set_camera cam_x, cam_y
+    def set_camera(cam_x, cam_y)
       @cam.x = cam_x
       @cam.y = cam_y
       set_bounds
@@ -122,7 +122,7 @@ module AGL
     #     cause the camera to move to the left.
     # [y] The amount of pixels to move vertically. Negative values will cause
     #     the camera to move up.
-    def move_camera x, y
+    def move_camera(x, y)
       @cam.x += x
       @cam.y += y
       set_bounds
@@ -158,26 +158,26 @@ module AGL
           v4 = get_isometric_position(0, @cam.h - 1)
           if v1.x < -@max_offset
             offset = -(v1.x + @max_offset)
-            @cam.x += offset * Sqrt2Div2
-            @cam.y += offset * Sqrt2Div2 / @tile_ratio
+            @cam.x += offset * SQRT_2_DIV_2
+            @cam.y += offset * SQRT_2_DIV_2 / @tile_ratio
             v1.x = -@max_offset
           end
           if v2.y < -@max_offset
             offset = -(v2.y + @max_offset)
-            @cam.x -= offset * Sqrt2Div2
-            @cam.y += offset * Sqrt2Div2 / @tile_ratio
+            @cam.x -= offset * SQRT_2_DIV_2
+            @cam.y += offset * SQRT_2_DIV_2 / @tile_ratio
             v2.y = -@max_offset
           end
           if v3.x > @iso_abs_size.x + @max_offset
             offset = v3.x - @iso_abs_size.x - @max_offset
-            @cam.x -= offset * Sqrt2Div2
-            @cam.y -= offset * Sqrt2Div2 / @tile_ratio
+            @cam.x -= offset * SQRT_2_DIV_2
+            @cam.y -= offset * SQRT_2_DIV_2 / @tile_ratio
             v3.x = @iso_abs_size.x + @max_offset
           end
           if v4.y > @iso_abs_size.y + @max_offset
             offset = v4.y - @iso_abs_size.y - @max_offset
-            @cam.x += offset * Sqrt2Div2
-            @cam.y -= offset * Sqrt2Div2 / @tile_ratio
+            @cam.x += offset * SQRT_2_DIV_2
+            @cam.y -= offset * SQRT_2_DIV_2 / @tile_ratio
             v4.y = @iso_abs_size.y + @max_offset
           end
         else
@@ -218,7 +218,7 @@ module AGL
     def initialize_isometric
       @x_offset = (@size.y * 0.5 * @tile_size.x).round
       @tile_ratio = @tile_size.x.to_f / @tile_size.y
-      square_size = @tile_size.x * Sqrt2Div2
+      square_size = @tile_size.x * SQRT_2_DIV_2
       @inverse_square_size = 1 / square_size
       @iso_abs_size = Vector.new(square_size * @size.x, square_size * @size.y)
       a = (@size.x + @size.y) * 0.5 * @tile_size.x
@@ -227,11 +227,11 @@ module AGL
       if @limit_cam
         actual_cam_h = @cam.h * @tile_ratio
         @max_offset = actual_cam_h < @cam.w ? actual_cam_h : @cam.w
-        @max_offset *= Sqrt2Div2
+        @max_offset *= SQRT_2_DIV_2
       end
     end
 
-    def get_isometric_position scr_x, scr_y
+    def get_isometric_position(scr_x, scr_y)
       # Escreve a posição em relação a origem (no centro do mapa)
       center = get_center
       position = Vector.new scr_x + @cam.x - center.x, scr_y + @cam.y - center.y
@@ -243,7 +243,7 @@ module AGL
       center.y *= @tile_ratio
 
       # Rotaciona o vetor posição -45°
-      position.rotate! MinusPiDiv4
+      position.rotate! MINUS_PI_DIV_4
 
       # Retorna a referência da posição para o canto da tela
       position += center

data/lib/minigl/movement.rb

@@ -1,6 +1,6 @@
 require_relative 'global'
 
-module AGL
+module MiniGL
   # Represents an object with a rectangular bounding box and the +passable+
   # property. It is the simplest structure that can be passed as an element of
   # the +obst+ array parameter of the +move+ method.
@@ -31,7 +31,7 @@ module AGL
     # [passable] Whether a moving object can pass through this block when
     # coming from below. This is a common feature of platforms in platform
     # games.
-    def initialize x, y, w, h, passable
+    def initialize(x, y, w, h, passable)
       @x = x; @y = y; @w = w; @h = h
       @passable = passable
     end
@@ -66,6 +66,8 @@ module AGL
     # from left to right when +false+).
     attr_reader :left
 
+    attr_reader :ratio # :nodoc:
+
     # Creates a new ramp.
     #
     # Parameters:
@@ -82,12 +84,14 @@ module AGL
     #     highest).
     # [left] Whether the height of the ramp increases from left to right. Use
     #        +false+ for a ramp that goes down from left to right.
-    def initialize x, y, w, h, left
+    def initialize(x, y, w, h, left)
       @x = x
       @y = y
       @w = w
       @h = h
       @left = left
+      @ratio = @h.to_f / @w
+      @factor = Math.cos(@w / Math.sqrt(@w**2 + @h**2))
     end
 
     # Checks if an object is in contact with this ramp (standing over it).
@@ -95,8 +99,8 @@ module AGL
     # Parameters:
     # [obj] The object to check contact with. It must have the +x+, +y+, +w+
     #       and +h+ accessible attributes determining its bounding box.
-    def contact? obj
-      obj.x.round(6) == get_x(obj).round(6) && obj.y.round(6) == get_y(obj).round(6)
+    def contact?(obj)
+      obj.x + obj.w > @x && obj.x < @x + @w && obj.x.round(6) == get_x(obj).round(6) && obj.y.round(6) == get_y(obj).round(6)
     end
 
     # Checks if an object is intersecting this ramp (inside the corresponding
@@ -105,40 +109,41 @@ module AGL
     # Parameters:
     # [obj] The object to check intersection with. It must have the +x+, +y+,
     #       +w+ and +h+ accessible attributes determining its bounding box.
-    def intersects obj
+    def intersect?(obj)
       obj.x + obj.w > @x && obj.x < @x + @w && obj.y > get_y(obj) && obj.y <= @y + @h - obj.h
     end
 
     # :nodoc:
-    def can_collide? obj
-      @can_collide = (obj.speed.y >= 0 and not intersects(obj))
+    def check_can_collide(m)
+      y = get_y(m) + m.h
+      @can_collide = m.x + m.w > @x && @x + @w > m.x && m.y < y && m.y + m.h > y
     end
 
-    def check_intersection obj
-      if @can_collide and intersects obj
+    def check_intersection(obj)
+      if @can_collide and intersect? obj
+        counter = @left && obj.prev_speed.x > 0 || !@left && obj.prev_speed.x < 0
+        if obj.prev_speed.y > 0 && counter
+          dx = get_x(obj) - obj.x
+          s = (obj.prev_speed.y.to_f / obj.prev_speed.x).abs
+          dx /= s + @ratio
+          obj.x += dx
+        end
         obj.y = get_y obj
+        if counter
+          obj.speed.x *= @factor
+        end
         obj.speed.y = 0
-        # a = @w / @h
-        # x = get_x(obj)
-        # y = get_y(obj)
-        # w = obj.x - x
-        # h = obj.y - y
-        # dx = w * h / (w * a + h)
-        # dy = dx * a
-        #
-        # obj.x -= dx
-        # obj.y -= dy
-        # obj.speed.x *= (@w / (@w + @h))
-        # obj.speed.y = 0
       end
     end
 
-    def get_x obj
+    def get_x(obj)
+      return obj.x if @left && obj.x + obj.w > @x + @w
       return @x + (1.0 * (@y + @h - obj.y - obj.h) * @w / @h) - obj.w if @left
+      return obj.x if obj.x < @x
       @x + (1.0 * (obj.y + obj.h - @y) * @w / @h)
     end
 
-    def get_y obj
+    def get_y(obj)
       return @y - obj.h if @left && obj.x + obj.w > @x + @w
       return @y + (1.0 * (@x + @w - obj.x - obj.w) * @h / @w) - obj.h if @left
       return @y - obj.h if obj.x < @x
@@ -161,6 +166,10 @@ module AGL
     # y: vertical component).
     attr_reader :speed
 
+    # A Vector with the speed limits for the object (x: horizontal component,
+    # y: vertical component).
+    attr_reader :max_speed
+
     # Width of the bounding box.
     attr_reader :w
 
@@ -197,6 +206,8 @@ module AGL
     # be applied in the next time +move+ is called.
     attr_accessor :stored_forces
 
+    attr_reader :prev_speed # :nodoc:
+
     # Returns the bounding box as a Rectangle.
     def bounds
       Rectangle.new @x, @y, @w, @h
@@ -213,24 +224,25 @@ module AGL
     #        objects that <code>include Movement</code>.
     # [ramps] An array of ramps to be considered in the collision checking.
     #         Ramps must be instances of Ramp (or derived classes).
-    def move forces, obst, ramps
-      forces.x += Game.gravity.x; forces.y += Game.gravity.y
+    def move(forces, obst, ramps)
+      forces.x += G.gravity.x; forces.y += G.gravity.y
       forces.x += @stored_forces.x; forces.y += @stored_forces.y
       @stored_forces.x = @stored_forces.y = 0
 
-      # check_contact obst, ramps
       forces.x = 0 if (forces.x < 0 and @left) or (forces.x > 0 and @right)
       forces.y = 0 if (forces.y < 0 and @top) or (forces.y > 0 and @bottom)
 
+      if @bottom.is_a? Ramp and @bottom.ratio >= G.ramp_slip_threshold
+        forces.x = (@bottom.left ? -1 : 1) * 0.1
+      end
+
       @speed.x += forces.x / @mass; @speed.y += forces.y / @mass
-      @speed.x = 0 if @speed.x.abs < @min_speed.x
-      @speed.y = 0 if @speed.y.abs < @min_speed.y
+      @speed.x = 0 if @speed.x.abs < G.min_speed.x
+      @speed.y = 0 if @speed.y.abs < G.min_speed.y
       @speed.x = (@speed.x <=> 0) * @max_speed.x if @speed.x.abs > @max_speed.x
       @speed.y = (@speed.y <=> 0) * @max_speed.y if @speed.y.abs > @max_speed.y
 
-      ramps.each do |r|
-        r.can_collide? self
-      end
+      @prev_speed = @speed.clone
 
       x = @speed.x < 0 ? @x + @speed.x : @x
       y = @speed.y < 0 ? @y + @speed.y : @y
@@ -239,7 +251,10 @@ module AGL
       move_bounds = Rectangle.new x, y, w, h
       coll_list = []
       obst.each do |o|
-        coll_list << o if move_bounds.intersects o.bounds
+        coll_list << o if move_bounds.intersect? o.bounds
+      end
+      ramps.each do |r|
+        r.check_can_collide move_bounds
       end
 
       if coll_list.length > 0
@@ -251,8 +266,12 @@ module AGL
           elsif dn; y_lim = find_down_limit coll_list
           elsif up; y_lim = find_up_limit coll_list
           end
-          if rt && @x + @w + @speed.x > x_lim; @x = x_lim - @w; @speed.x = 0
-          elsif lf && @x + @speed.x < x_lim; @x = x_lim; @speed.x = 0
+          if rt && @x + @w + @speed.x > x_lim
+            @x = x_lim - @w
+            @speed.x = 0
+          elsif lf && @x + @speed.x < x_lim
+            @x = x_lim
+            @speed.x = 0
           elsif dn && @y + @h + @speed.y > y_lim; @y = y_lim - @h; @speed.y = 0
           elsif up && @y + @speed.y < y_lim; @y = y_lim; @speed.y = 0
           end
@@ -306,6 +325,11 @@ module AGL
       @x += @speed.x
       @y += @speed.y
 
+      # Keeping contact with ramp
+      # if @speed.y == 0 and @speed.x.abs <= G.ramp_contact_threshold and @bottom.is_a? Ramp
+      #   @y = @bottom.get_y(self)
+      #   puts 'aqui'
+      # end
       ramps.each do |r|
         r.check_intersection self
       end
@@ -323,9 +347,15 @@ module AGL
     #             checking, and carried along when colliding from above.
     #             Obstacles must be instances of Block (or derived classes),
     #             or objects that <code>include Movement</code>.
-    def move_carrying aim, speed, obstacles
+    def move_carrying(aim, speed, obstacles)
       x_d = aim.x - @x; y_d = aim.y - @y
       distance = Math.sqrt(x_d**2 + y_d**2)
+
+      if distance == 0
+        @speed.x = @speed.y = 0
+        return
+      end
+
       @speed.x = 1.0 * x_d * speed / distance
       @speed.y = 1.0 * y_d * speed / distance
 
@@ -363,9 +393,15 @@ module AGL
     # [aim] A Vector specifying where the object will move to.
     # [speed] The constant speed at which the object will move. This must be
     #         provided as a scalar, not a vector.
-    def move_free aim, speed
+    def move_free(aim, speed)
       x_d = aim.x - @x; y_d = aim.y - @y
       distance = Math.sqrt(x_d**2 + y_d**2)
+
+      if distance == 0
+        @speed.x = @speed.y = 0
+        return
+      end
+
       @speed.x = 1.0 * x_d * speed / distance
       @speed.y = 1.0 * y_d * speed / distance
 
@@ -385,39 +421,37 @@ module AGL
     end
 
     # Causes the object to move in cycles across multiple given points (the
-    # method must be called repeatedly, and it returns the value that must be
-    # provided to +cur_point+ after the first call). If obstacles are
-    # provided, it will behave as an elevator (as in +move_carrying+).
+    # first point in the array is the first point the object will move towards,
+    # so it doesn't need to be equal to the current/initial position). If
+    # obstacles are provided, it will behave as an elevator (as in
+    # +move_carrying+).
     #
     # Parameters:
     # [points] An array of Vectors representing the path that the object will
     #          perform.
-    # [cur_point] The index of the point in the path that the object is
-    #             currently moving to. In the first call, it is a good idea to
-    #             provide 0, while in the subsequent calls, you must provide
-    #             the return value of this method.
     # [speed] The constant speed at which the object will move. This must be
     #         provided as a scalar, not a vector.
     # [obstacles] An array of obstacles to be considered in the collision
     #             checking, and carried along when colliding from above.
     #             Obstacles must be instances of Block (or derived classes),
     #             or objects that <code>include Movement</code>.
-    def cycle points, cur_point, speed, obstacles = nil
+    def cycle(points, speed, obstacles = nil)
+      @cur_point = 0 if @cur_point.nil?
       if obstacles
-        move_carrying points[cur_point], speed, obstacles
+        move_carrying points[@cur_point], speed, obstacles
       else
-        move_free points[cur_point], speed
+        move_free points[@cur_point], speed
       end
       if @speed.x == 0 and @speed.y == 0
-        if cur_point == points.length - 1; cur_point = 0
-        else; cur_point += 1; end
+        if @cur_point == points.length - 1; @cur_point = 0
+        else; @cur_point += 1; end
       end
-      cur_point
     end
 
   private
 
-    def check_contact obst, ramps
+    def check_contact(obst, ramps)
+      prev_bottom = @bottom
       @top = @bottom = @left = @right = nil
       obst.each do |o|
         x2 = @x + @w; y2 = @y + @h; x2o = o.x + o.w; y2o = o.y + o.h
@@ -433,10 +467,21 @@ module AGL
             break
           end
         end
+        if @bottom.nil?
+          ramps.each do |r|
+            if r == prev_bottom && @x + @w > r.x && r.x + r.w > @x &&
+                @prev_speed.x.abs <= G.ramp_contact_threshold &&
+                @prev_speed.y >= 0
+              @y = r.get_y self
+              @bottom = r
+              break
+            end
+          end
+        end
       end
     end
 
-    def find_right_limit coll_list
+    def find_right_limit(coll_list)
       limit = @x + @w + @speed.x
       coll_list.each do |c|
         limit = c.x if !c.passable && c.x < limit
@@ -444,7 +489,7 @@ module AGL
       limit
     end
 
-    def find_left_limit coll_list
+    def find_left_limit(coll_list)
       limit = @x + @speed.x
       coll_list.each do |c|
         limit = c.x + c.w if !c.passable && c.x + c.w > limit
@@ -452,7 +497,7 @@ module AGL
       limit
     end
 
-    def find_down_limit coll_list
+    def find_down_limit(coll_list)
       limit = @y + @h + @speed.y
       coll_list.each do |c|
         limit = c.y if c.y < limit && c.y >= @y + @h
@@ -460,7 +505,7 @@ module AGL
       limit
     end
 
-    def find_up_limit coll_list
+    def find_up_limit(coll_list)
       limit = @y + @speed.y
       coll_list.each do |c|
         limit = c.y + c.h if !c.passable && c.y + c.h > limit