fantasy 0.1.1 → 0.1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98083689a972e68c27f07ae5c9c8ef9818c1b1215fbf2baccc541233efca6827
-  data.tar.gz: db32ef03fd54c4711b9b38b9f4e3f4ad587839fc4d78523982c6c69f85cb0ab4
+  metadata.gz: 58bcb1e825d5cdf5185a26d5bd1dd972fb585ddeefa8fab964984e4ddd975584
+  data.tar.gz: eea7d4e258d2a3f949b97b187fd540e9e7702515fcac381c5ae53b244f06c546
 SHA512:
-  metadata.gz: 5a6d2c503880c672d147909cd5ab5a88639ab4e3e019ea5b81601c4aa0cc967e03e5c8b48f1994309ab379e83012f5a103043ba6b64989ba8009d2c7e3950174
-  data.tar.gz: 93f37ba3a6fde17d55ba7aa203a1ade6645e69af8d670d37b5a7d78442c5c1dc4bb115784520cbd5b6a9ef661b18e6dbc2b094dab4c2a54feca8d37e4c527303
+  metadata.gz: 9a4ec479708e117036d068ddcf3c5f33f0338a85e324ca7708bd1922c41c632804e90733fea5c3d2dc258f2d00e2b8fbf37e30d4cf4e0afec70e663af2125319
+  data.tar.gz: 2beeb1fdb476866e25db35ee12559c7571656e07a0ab9c112d832ec1a0fdffa520f471fc4054bc67a4e14154f445aa9e9b8d5e889d988f64920f04931c53bb01

data/README.md

@@ -1,11 +1,83 @@
 # Ruby in Fantasy
 
+Simple toolbox library and lean API to build great mini games in Ruby.
+
 An upper layer over Gosu library to offer a more friendly API for an easy and lean game development.
 
 Specially intended to use Ruby as a learning language to introduce children into programming.
 
 **Attention**: This project is in early development phase, right now it is just an experiment
 
+## Use
+
+### Hello World
+
+```ruby
+require "fantasy"
+
+SCREEN_WIDTH = 320
+SCREEN_HEIGHT = 240
+
+on_game do
+  message = HudText.new(position: Coordinates.new(10, 10))
+  message.text = "Hello, World!"
+  message.size = "big"
+end
+
+start!
+```
+
+### Action game
+
+```ruby
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 360
+
+on_game do
+  player = Actor.new("warrior")
+  player.position = Coordinates.new(100, 100)
+  points = HudText.new(position: Coordinates.new(10, 20))
+  points.text = 0
+
+  on_space_bar do
+    Sound.play("shoot")
+    bullet = Actor.new("bullet")
+    bullet.position = player.position
+    bullet.speed = 100
+    bullet.direction = Coordinates.up
+    bullet.on_collision do |other|
+      if other.name == "enemy"
+        Sound.play("impact")
+        other.destroy
+        bullet.destroy
+        points.text += 1
+      end
+    end
+  end
+
+  player.on_collision do |other|
+    if other.name == "enemy"
+      Sound.play("game_over")
+      Global.go_to_end
+    end
+  end
+end
+
+on_end do
+  HudText.new(position: Coordinates.new(10, 100), text: "You are dead. Press space to re-tart")
+
+  on_space_bar do
+    Global.go_to_game
+  end
+end
+
+start!
+```
+
+## Examples
+
+See the [Ruby in Fantasy Games Collection](https://github.com/fguillen/RubyInFantasyGames).
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,6 +96,19 @@ Or install it yourself as:
 
 ## Features
 
+### Game Scene transitions
+
+Easy to configure 3 basic game states:
+
+- Game presentation scene
+- Game game scene
+- Game end scene
+- Other scenes, like levels or such (TODO)
+
+Each state should be independent and unique Actors and other elements can be created and configured for each state
+
+Built-in mechanism to move from one state to another.
+
 ### Actor
 
 Managing game elements which have (optionally) image, movement and collision
@@ -36,6 +121,7 @@ Managing game elements which have (optionally) image, movement and collision
 - Gravity (TODO)
 - Animations (TODO)
 - Possibility to extend Actor class or instantiate it directly for simple characters
+- Allowing magic instance properties (Like in OpenStruct). So programmer can do `actor.stuff = 1` and it is valid (TODO)
 
 ### Clock
 
@@ -79,7 +165,7 @@ For easy creation of head-up display components.
 
 ### Debug Mode
 
-When active different attributes from all the Actors and HUD elements will be visible in the screen.
+Press `d` to activate it. When active debug visuals are shown:
 
 - Position
 - Collider
@@ -99,18 +185,6 @@ Actors in the game will be rendered in the relative position to this camera.
 
 - Not deal with RGB or anything, just a list of colors (TODO)
 
-### Game Scene transitions
-
-Easy to configure 3 basic game states:
-
-- Game presentation scene
-- Game game scene
-- Game end scene
-- Other scenes, like levels or such (TODO)
-
-Each state should be independent and unique Actors and other elements can be created and configured for each state
-
-Built-in mechanism to move from one state to another.
 
 ### Pause Game (TODO)
 
@@ -129,8 +203,8 @@ Direct and easy way to play a sound
 Simple way to set up:
 
 - Background color
-- Image background (TODO)
-- Repeatable image background (TODO)
+- Image background
+- Repeatable image background
 
 ### Data Persistance (TODO)
 
@@ -143,20 +217,224 @@ Easy access to keyboard and mouse inputs on any part of the code. Specially in t
 - Allow "on_space_bar" and each Actor (TODO)
 - Allow multiple "on_space_bar" (TODO)
 - Remove "on_space_bar" when changing scene (TODO)
+- Detect when key/mouse button is pressed in the actual frame in any part of the code (TODO)
+
+### Tile Map (TODO)
+
+For easy creation of:
+
+- Top-down map levels (TODO)
+- Platformer map levels (TODO)
+
+### Tweens (TODO)
+
+Multiple movement animation effects like in [DoTween](http://dotween.demigiant.com/documentation.php) (TODO)
 
 ## API
 
+### Game Scene transitions
+
+Configure your game elements on each Scene:
+
+```ruby
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 360
+
+# (Optional)
+on_presentation do
+  # Game elements running when the game loads
+end
+
+on_game do
+  # Game elements running when in game Scene
+end
+
+# (Optional)
+on_end do
+  # Game elements running when game is ended
+end
+```
+
+How to go from Scene to Scene:
+
+```ruby
+Global.go_to_presentation
+Global.go_to_game
+Global.go_to_end
+```
+
+#### Example
+
+```ruby
+on_presentation do
+  HudText.new(position: Coordinates.new(10, 100), text: "Press space to start")
+
+  on_space_bar do
+    Global.go_to_game
+  end
+end
+
+on_game do
+  # [...]
+  if player.dead
+    Global.go_to_end
+  end
+end
+
+on_end do
+  HudText.new(position: Coordinates.new(10, 100), text: "You are dead. Press space to re-tart")
+
+  on_space_bar do
+    Global.go_to_presentation
+  end
+end
+```
+
+### Actor
+
+Actor can be used directly:
+
+```ruby
+player = Actor.new("warrior") # ./images/warrior.png
+player.position = Coordinates.new(100, 100)
+player.solid = true
+player.speed = 200
+player.layer = 1
+player.move_with_cursors
+
+player.on_collision do |other|
+  if other.name == "enemy"
+    player.destroy
+  end
+end
+
+player.on_after_move do
+  if player.position.x > SCREEN_WIDTH
+    player.position.x = SCREEN_WIDTH
+  end
+
+  if player.position.x < 0
+    player.position.x = 0
+  end
+end
+```
+
+Or in a subclass:
+
+```ruby
+class Player < Actor
+  def initialize
+    super("warrior") # ./images/warrior.png
+    @position = Coordinates.new(100, 100)
+    @solid = true
+    @speed = 200
+    @layer = 1
+    @direction = Coordinates.zero
+    move_with_cursors
+  end
+
+  on_collision do |other|
+    if other.name == "enemy"
+      destroy
+    end
+  end
+
+  on_after_move do
+    if @position.x > SCREEN_WIDTH
+      @position.x = SCREEN_WIDTH
+    end
+
+    if @position.x < 0
+      @position.x = 0
+    end
+  end
+end
+```
+
+### Clock
+
+```ruby
+clock =
+  Clock.new do
+    enemy.attack
+    sleep(1)
+    enemy.defend
+  end
+
+clock.run_now
+clock.run_on(seconds: 2)
+clock.repeat(seconds: 2, times: 10)
+clock.stop
+```
+
+### Background
+
+```ruby
+# Simple color
+on_presentation do
+  Global.background = Color.new(r: 34, g: 35, b: 35)
+end
+
+# Replicable (by default) Image
+# position is relative to Global.camera
+on_game do
+  background = Background.new(image_name: "beach")
+  # background.replicable = false # if you don't want the image to replicate
+  background.scale = 6
+end
+```
+
+### Camera
+
+```ruby
+on_game do
+  on_loop do
+    # Camera follows player
+    Global.camera.position.y = player.position.y - (SCREEN_HEIGHT / 2)
+  end
+end
+```
+
+### Sound
+
+```ruby
+Sound.play("shoot") # ./sounds/shoot.wav
+```
+
+
+### UI
+
+#### HUD Text
+
+```ruby
+timer = HudText.new(position: Coordinates.new(20, 10))
+timer.text = 0
+timer.size = "big"
+
+Clock.new { timer.text += 1 }.repeat(seconds: 1)
+```
+
+#### HUD Image
+
+```ruby
+icon = HudImage.new(position: Coordinates.new(SCREEN_WIDTH - 220, 8), image_name: "ring")
+icon.scale = 4
+icon.visible = true
+
+Clock.new { icon.visible = !icon.visible }.repeat(seconds: 1)
+```
 
 
 ## Credits for assets
 
-- Sprites: www.kenney.nl
 - Font: VT323 Project Authors (peter.hull@oikoi.com)
 
 ## Bugs
 
 - When dragging in debug mode new elements are being added to the drag (TODO)
 - Rubocop is not passing
+- Tests are missing
+- Allow Ruby 2.5+
 
 ## Development
 

data/fantasy.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["Fernando Guillen"]
   spec.email = ["fguillen.mail@gmail.com"]
 
-  spec.summary = "Simple toolbox library and lean API to build great mini games"
-  spec.description = "Simple toolbox library and lean API to build great mini games"
+  spec.summary = "Simple toolbox library and lean API to build great mini games in Ruby"
+  spec.description = "Simple toolbox library and lean API to build great mini games in Ruby"
   spec.homepage = "https://github.com/fguillen/fantasy"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.0.0"

data/lib/fantasy/actor.rb

@@ -1,8 +1,11 @@
 class Actor
+  include MoveByCursor
+
   attr_reader :image, :moving_with_cursors
-  attr_accessor :position, :direction, :speed, :solid, :scale, :name, :layer
+  attr_accessor :image_name, :position, :direction, :speed, :solid, :scale, :name, :layer
 
   def initialize(image_name)
+    @image_name = image_name
     @image = Image.new(image_name)
     @name = image_name
     @position = Coordinates.new(0, 0)
@@ -80,13 +83,12 @@ class Actor
         @position = @position + (@direction * @speed * Global.frame_time)
 
         if solid?
-          actual_collisions = collisions
-          actual_collisions.each do |actor|
+          collisions.each do |actor|
             collision_with(actor)
             actor.collision_with(self)
           end
 
-          @position = @last_position if actual_collisions.any?
+          @position = @last_position if collisions.any? # we don't cache collisions because position may be changed on collision callback
         end
       end
     end
@@ -114,20 +116,6 @@ class Actor
     @on_collision_callback.call(actor) unless @on_collision_callback.nil?
   end
 
-  def calculate_direction_by_cursors
-    if Gosu.button_down?(Gosu::KB_DOWN)
-      @direction = Coordinates.down
-    elsif Gosu.button_down?(Gosu::KB_UP)
-      @direction = Coordinates.up
-    elsif Gosu.button_down?(Gosu::KB_RIGHT)
-      @direction = Coordinates.right
-    elsif Gosu.button_down?(Gosu::KB_LEFT)
-      @direction = Coordinates.left
-    else
-      @direction = Coordinates.zero
-    end
-  end
-
   def collisions
     Global.actors.reject { |e| e == self }.select { |e| e.solid? }.select do |actor|
       Utils.collision? self, actor
@@ -138,4 +126,37 @@ class Actor
     @on_destroy_callback.call unless @on_destroy_callback.nil?
     Global.actors.delete(self)
   end
+
+  def clone
+    actor = self.class.new(@image_name)
+    actor.image_name = @image_name
+    actor.name = @name
+    actor.position = @position.clone
+    actor.direction = @direction.clone
+    actor.speed = @speed
+    actor.scale = @scale
+    actor.moving_with_cursors if @moving_with_cursors
+    actor.solid = @solid
+    actor.layer = @layer
+
+    actor.on_after_move_callback = @on_after_move_callback
+    actor.on_collision_callback = @on_collision_callback
+    actor.on_destroy_callback = @on_destroy_callback
+
+    actor
+  end
+
+  protected
+
+  def on_after_move_callback=(block)
+    @on_after_move_callback = block
+  end
+
+  def on_collision_callback=(block)
+    @on_collision_callback = block
+  end
+
+  def on_destroy_callback=(block)
+    @on_destroy_callback = block
+  end
 end

data/lib/fantasy/background.rb

@@ -0,0 +1,62 @@
+class Background
+  attr_accessor :scale, :color, :visible, :position, :layer
+
+  def initialize(image_name:)
+    @image = Image.new(image_name)
+    @name = image_name
+    @position = Coordinates.zero
+    @scale = 1
+    @visible = true
+    @draggable_on_debug = true
+    @dragging = false
+    @layer = -100
+    @replicable = true
+
+    Global.backgrounds.push(self)
+  end
+
+  def width
+    @image.width() * @scale
+  end
+
+  def height
+    @image.height() * @scale
+  end
+
+  def position_in_camera
+    @position - Global.camera.position
+  end
+
+  def draw
+    if @visible
+      if @replicable
+        draw_replicable
+      else
+        draw_normal
+      end
+    end
+  end
+
+  def draw_normal
+    @image.draw(x: position_in_camera.x, y: position_in_camera.y, scale: @scale)
+  end
+
+  # Camera relative Tiles
+  def draw_replicable
+    tiles_delta_x = (position_in_camera.x % width) - width
+    tiles_delta_y = (position_in_camera.y % height) - height
+
+    tiles_needed_horizontal = ((SCREEN_WIDTH - (tiles_delta_x + width)) / width.to_f).ceil + 1
+    tiles_needed_vertical = ((SCREEN_HEIGHT - (tiles_delta_y + height)) / height.to_f).ceil + 1
+
+    tiles_needed_horizontal.times do |index_horizontal|
+      tiles_needed_vertical.times do |index_vertical|
+        @image.draw(x: tiles_delta_x + (width * index_horizontal), y: tiles_delta_y + (height * index_vertical), scale: @scale)
+      end
+    end
+  end
+
+  def destroy
+    Global.backgrounds.delete(self)
+  end
+end

data/lib/fantasy/base.rb

@@ -54,6 +54,7 @@ def on_mouse_button_right(&block)
 end
 
 def start!
+  Global.setup
   Global.game = Game.new
   Global.game.show
 end

data/lib/fantasy/camera.rb

@@ -1,7 +1,31 @@
 class Camera
-  attr_accessor :position
+  include MoveByCursor
+
+  attr_accessor :position, :direction, :speed
 
   def initialize(position: Coordinates.zero)
     @position = position
+    @direction = Coordinates.zero
+    @speed = 0
+    @moving_with_cursors = false
+    @on_after_move_callback = nil
+  end
+
+  def move_with_cursors
+    @moving_with_cursors = true
+  end
+
+  def move
+    calculate_direction_by_cursors if @moving_with_cursors
+
+    if @direction != Coordinates.zero && !@speed.zero?
+      @position = @position + (@direction * @speed * Global.frame_time)
+    end
+
+    @on_after_move_callback.call unless @on_after_move_callback.nil?
+  end
+
+  def on_after_move(&block)
+    @on_after_move_callback = block
   end
 end

data/lib/fantasy/clock.rb

@@ -1,7 +1,10 @@
 class Clock
+  attr_accessor :persistent
+
   def initialize(&block)
     @block = block
     @thread = nil
+    @persistent = false # if persistent, clock is not stopped when loading new scene
 
     Global.clocks << self
   end
@@ -28,12 +31,22 @@ class Clock
         while(times_executed < times)
           @block.call
           times_executed += 1;
-          sleep(seconds)
+
+          seconds_to_sleep = seconds.is_a?(Range) ? rand(seconds) : seconds
+          sleep(seconds_to_sleep)
         end
       end
   end
 
   def stop
-    Thread.kill(@thread)
+    Thread.kill(@thread) unless @thread.nil?
+  end
+
+  def started?
+    !@thread.nil?
+  end
+
+  def persistent?
+    @persistent
   end
 end

data/lib/fantasy/coordinates.rb

@@ -28,4 +28,8 @@ class Coordinates < Vector2d
   def y=(value)
     @y = value
   end
+
+  def clone
+    Coordinates.new(@x, @y)
+  end
 end

data/lib/fantasy/draggable.rb

@@ -1,26 +1,17 @@
 module Draggable
   def drag
-    puts "XXX: dragging 1 #{name}"
     mouse_position = Global.mouse_position
 
-    puts "@draggable_on_debug: #{@draggable_on_debug}"
-    puts "@dragging: #{@dragging}"
-    puts "Gosu.button_down?(Gosu::MS_LEFT): #{Gosu.button_down?(Gosu::MS_LEFT)}"
-    puts "collision: #{Utils.collision_at?(self, mouse_position.x, mouse_position.y)}"
-
     if @draggable_on_debug && !@dragging && Gosu.button_down?(Gosu::MS_LEFT) && Utils.collision_at?(self, mouse_position.x, mouse_position.y)
-      puts "XXX: dragging start #{name}"
       @dragging = true
       @dragging_offset = mouse_position - @position
     end
 
     if @dragging && !Gosu.button_down?(Gosu::MS_LEFT)
-      puts "XXX: dragging end #{name}"
       @dragging = false
     end
 
     if @dragging
-      puts "XXX: dragging 3 #{name}"
       @position = mouse_position - @dragging_offset
     end
   end

data/lib/fantasy/global.rb

@@ -2,7 +2,7 @@ require "ostruct"
 
 module Global
   class << self
-    attr_accessor :actors, :hud_texts, :hud_images, :clocks
+    attr_accessor :actors, :hud_texts, :hud_images, :backgrounds, :tile_maps, :clocks
     attr_accessor :debug
     attr_accessor :setup_proc, :loop_proc, :button_proc
     attr_accessor :presentation_proc, :game_proc, :end_proc
@@ -25,6 +25,8 @@ module Global
       @actors = []
       @hud_texts = []
       @hud_images = []
+      @backgrounds = []
+      @tile_maps = []
       @clocks = []
       @last_frame_at = Time.now
       @debug = false
@@ -33,11 +35,19 @@ module Global
       @references = OpenStruct.new
       @camera = Camera.new(position: Coordinates.zero)
       @game_state = Global.presentation_proc.nil? ? "game" : "presentation"
+      @scene_started_at = Time.now
 
-      @presentation_proc = Global.default_on_presentation if @presentation_proc.nil?
-      @game_proc = Global.default_on_game if @game_proc.nil?
-      @end_proc = Global.default_on_end if @end_proc.nil?
-      @paused = false
+      if @presentation_proc.nil?
+        on_presentation { Global.default_on_presentation  }
+      end
+
+      if @game_proc.nil?
+        on_game { Global.default_on_game  }
+      end
+
+      if @end_proc.nil?
+        on_end { Global.default_on_end  }
+      end
     end
 
     def update
@@ -74,7 +84,7 @@ module Global
       puts "Game stage 'presentation'"
 
       clear_state_elements
-      presentation_proc.call
+      @presentation_proc.call
     end
 
     def go_to_game
@@ -92,15 +102,27 @@ module Global
     end
 
     def clear_state_elements
+      @scene_started_at = Time.now
       @actors.clear
       @hud_texts.clear
       @hud_images.clear
-      @clocks.each(&:stop)
+      @backgrounds.clear
+      @tile_maps.clear
+      @clocks.reject(&:persistent?).each(&:stop)
       @background = Color.new(r: 0, g: 0, b: 0)
     end
 
     def mouse_position
       Coordinates.new(Global.game.mouse_x, Global.game.mouse_y)
     end
+
+    def setup
+      Sound.preload_sounds
+      Image.preload_images
+    end
+
+    def seconds_in_scene
+      Time.now - @scene_started_at
+    end
   end
 end

data/lib/fantasy/image.rb

@@ -22,6 +22,12 @@ class Image
       locate_image(image_name)
     end
 
+    def preload_images
+      Dir.each_child(base_path) do |file_name|
+        locate_image(file_name) unless file_name.start_with?(".")
+      end
+    end
+
     private
 
     def locate_image(image_name)
@@ -29,14 +35,17 @@ class Image
 
       puts "Initialize image: '#{image_name}'"
 
-      base_path = "#{Dir.pwd}/images"
-      file_name = Dir.entries(base_path).find { |e| e.start_with?("#{image_name}.") }
+      file_name = Dir.entries(base_path).find { |e| e =~ /^#{image_name}($|\.)/  }
 
-      raise "Image file not found with name '#{image_name}'" if file_name.nil?
+      raise "Image file not found with name '#{image_name}' in #{base_path}" if file_name.nil?
 
       @@images[image_name] = Gosu::Image.new("#{base_path}/#{file_name}", { retro: true })
 
       return @@images[image_name]
     end
+
+    def base_path
+      "#{Dir.pwd}/images"
+    end
   end
 end

data/lib/fantasy/includes/move_by_cursors.rb

@@ -0,0 +1,15 @@
+module MoveByCursor
+  def calculate_direction_by_cursors
+    if Gosu.button_down?(Gosu::KB_DOWN)
+      @direction = Coordinates.down
+    elsif Gosu.button_down?(Gosu::KB_UP)
+      @direction = Coordinates.up
+    elsif Gosu.button_down?(Gosu::KB_RIGHT)
+      @direction = Coordinates.right
+    elsif Gosu.button_down?(Gosu::KB_LEFT)
+      @direction = Coordinates.left
+    else
+      @direction = Coordinates.zero
+    end
+  end
+end

data/lib/fantasy/loop.rb

@@ -38,6 +38,8 @@ class Game < Gosu::Window
       e.move
     end
 
+    Global.camera.move
+
     Global.loop_proc.call() unless Global.loop_proc.nil?
   end
 
@@ -45,6 +47,8 @@ class Game < Gosu::Window
     Gosu.draw_rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, Global.background)
 
     (
+      Global.backgrounds +
+      Global.tile_maps +
       Global.actors +
       Global.hud_texts +
       Global.hud_images

data/lib/fantasy/sound.rb

@@ -11,8 +11,7 @@ module Sound
 
       puts "Initialize Sound: '#{sound_name}'"
 
-      base_path = "#{Dir.pwd}/sounds"
-      file_name = Dir.entries(base_path).find { |e| e.start_with?("#{sound_name}.") }
+      file_name = Dir.entries(base_path).find { |e| e =~ /^#{sound_name}($|\.)/ }
 
       raise "Sound file not found with name '#{sound_name}'" if file_name.nil?
 
@@ -20,5 +19,15 @@ module Sound
 
       return @@sounds[sound_name]
     end
+
+    def preload_sounds
+      Dir.each_child(base_path) do |file_name|
+        locate_sound(file_name) unless file_name.start_with?(".")
+      end
+    end
+
+    def base_path
+      "#{Dir.pwd}/sounds"
+    end
   end
 end

data/lib/fantasy/tile_map.rb

@@ -0,0 +1,78 @@
+class TileMap
+  attr_accessor :position
+
+  def initialize(map_name:, tiles:, tile_size: nil, tile_width: nil, tile_height: nil)
+    @tile_width = tile_width || tile_size
+    @tile_height = tile_height || tile_size
+
+    if(@tile_height.nil? or @tile_width.nil?)
+      raise("Tile size is not properly defined. Either you set a `tile_size` or a `tile_width` and `tile_height`")
+    end
+
+    @map_name = map_name
+    @tiles = tiles
+    @position = Coordinates.zero
+
+    @grid = TileMap.load_grid(@map_name)
+  end
+
+  def width
+    @grid.max(&:length) * @tile_width
+  end
+
+  def height
+    @grid.length * @tile_height
+  end
+
+  def spawn
+    tile_position = Coordinates.zero
+
+    @grid.each do |line|
+      tile_position.x = 0
+
+      line.each do |tile_index|
+        if !tile_index.nil?
+          actor = @tiles[tile_index].clone
+          actor.position.x = @position.x + (tile_position.x * @tile_width)
+          actor.position.y = @position.y + (tile_position.y * @tile_height)
+        end
+
+        tile_position.x += 1
+      end
+
+      tile_position.y += 1
+    end
+  end
+
+  private
+
+  class << self
+    @@maps = {}
+
+    def load_grid(map_name)
+      File.readlines(TileMap.locate_map(map_name), chomp: true).map do |line|
+        line.each_char.map do |char|
+          char == " " ? nil : char.to_i
+        end
+      end
+    end
+
+    def locate_map(map_name)
+      return @@maps[map_name] if @@maps[map_name]
+
+      puts "Initialize map: '#{map_name}'"
+
+      file_name = Dir.entries(base_path).find { |e| e =~ /^#{map_name}($|\.)/  }
+
+      raise "Map file not found with name '#{map_name}' in #{base_path}" if file_name.nil?
+
+      @@maps[map_name] = "#{base_path}/#{file_name}"
+
+      return @@maps[map_name]
+    end
+
+    def base_path
+      "#{Dir.pwd}/maps"
+    end
+  end
+end

data/lib/fantasy/tween.rb

@@ -0,0 +1,11 @@
+module Tween
+  def self.move_towards(from:, to:, speed:)
+    direction = to - from
+    step = [direction.length, speed * Global.frame_time].min
+
+    return to if step.zero?
+
+    direction = direction.normalize
+    return from + (direction * step)
+  end
+end

data/lib/fantasy/utils.rb

@@ -1,12 +1,15 @@
 module Utils
   # https://developer.mozilla.org/en-US/docs/Games/Techniques/2D_collision_detection
   def self.collision?(actor_1, actor_2)
-    (
-      actor_1.position.x < (actor_2.position.x + actor_2.width) &&
-      (actor_1.position.x + actor_1.width) > actor_2.position.x &&
-      actor_1.position.y < (actor_2.position.y + actor_2.height) &&
-      actor_1.position.y + actor_1.height > actor_2.position.y
-    )
+    result =
+      (
+        actor_1.position.x < (actor_2.position.x + actor_2.width) &&
+        (actor_1.position.x + actor_1.width) > actor_2.position.x &&
+        actor_1.position.y < (actor_2.position.y + actor_2.height) &&
+        actor_1.position.y + actor_1.height > actor_2.position.y
+      )
+
+    result
   end
 
   def self.collision_at?(actor, x, y)

data/lib/fantasy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fantasy
-  VERSION = "0.1.1"
+  VERSION = "0.1.5.1"
 end

data/lib/fantasy.rb

@@ -2,6 +2,8 @@
 require "gosu"
 
 require_relative "fantasy/version"
+require_relative "fantasy/includes/move_by_cursors"
+require_relative "fantasy/tween"
 require_relative "fantasy/draggable"
 require_relative "fantasy/color"
 require_relative "fantasy/actor"
@@ -12,7 +14,9 @@ require_relative "fantasy/clock"
 require_relative "fantasy/loop"
 require_relative "fantasy/hud_text"
 require_relative "fantasy/hud_image"
+require_relative "fantasy/background"
 require_relative "fantasy/sound"
 require_relative "fantasy/camera"
 require_relative "fantasy/image"
+require_relative "fantasy/tile_map"
 require_relative "fantasy/base"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fantasy
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.5.1
 platform: ruby
 authors:
 - Fernando Guillen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-11 00:00:00.000000000 Z
+date: 2022-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu
@@ -38,7 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.3
-description: Simple toolbox library and lean API to build great mini games
+description: Simple toolbox library and lean API to build great mini games in Ruby
 email:
 - fguillen.mail@gmail.com
 executables: []
@@ -58,6 +58,7 @@ files:
 - fonts/VT323-Regular.ttf
 - lib/fantasy.rb
 - lib/fantasy/actor.rb
+- lib/fantasy/background.rb
 - lib/fantasy/base.rb
 - lib/fantasy/camera.rb
 - lib/fantasy/clock.rb
@@ -68,8 +69,11 @@ files:
 - lib/fantasy/hud_image.rb
 - lib/fantasy/hud_text.rb
 - lib/fantasy/image.rb
+- lib/fantasy/includes/move_by_cursors.rb
 - lib/fantasy/loop.rb
 - lib/fantasy/sound.rb
+- lib/fantasy/tile_map.rb
+- lib/fantasy/tween.rb
 - lib/fantasy/utils.rb
 - lib/fantasy/version.rb
 homepage: https://github.com/fguillen/fantasy
@@ -98,5 +102,5 @@ requirements: []
 rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
-summary: Simple toolbox library and lean API to build great mini games
+summary: Simple toolbox library and lean API to build great mini games in Ruby
 test_files: []