RubyMan 0.0.2

data/lib/ruby_man/level_loader.rb

@@ -0,0 +1,49 @@
+require 'ruby_man/GameObjects/wall'
+require 'ruby_man/GameObjects/player'
+require 'ruby_man/GameObjects/food'
+require 'ruby_man/GameObjects/ghost'
+require 'ruby_man/GameObjects/hud'
+require 'ruby_man/GameObjects/door'
+require 'ruby_man/GameObjects/super_food'
+
+module RubyMan
+  # mixin for loading levels from files
+  # required method - add_object, level_loaded
+  module LevelLoader
+    def load_level_string(level_string, restart)
+      y = 0
+      level_string.lines do |line|
+        x = -1
+        line.each_char do |char|
+          x += 1
+          obj = LevelLoader.object_from_char(char)
+          next unless obj
+          next if restart && obj.class.persistent == true
+          obj.set_pos(x, y)
+          add_object(obj)
+        end
+        y += 1
+      end
+
+      add_object(Hud.new)
+
+      level_loaded
+    end
+
+    def load_level_file(level_name, restart)
+      f = File.open(ResourceManager.media(level_name))
+      load_level_string(f.read, restart)
+    end
+
+    def self.object_from_char(char)
+      case char.downcase
+      when 'p' then return Player.new
+      when '.' then return Food.new
+      when ':' then return SuperFood.new
+      when 'g' then return Ghost.new
+      when '_' then return Door.new
+      end
+      Wall.from_char(char) unless Wall.chars.index(char).nil?
+    end
+  end
+end

data/lib/ruby_man/resource_manager.rb

@@ -0,0 +1,103 @@
+require 'gosu'
+require 'ruby_man/sprite'
+
+module Gosu
+  # extension of Font for easier centered drawing
+  class Font
+    def draw_centered(text, x, y, z = 0,
+                      factor_x = 1, factor_y = 1,
+                      color = 0xffffffff, mode = :default)
+      w = text_width(text, factor_x)
+      draw(text, x - w / 2, y, z, factor_x, factor_y, color, mode)
+    end
+  end
+end
+
+module RubyMan
+  # Handles loading of resources for faster and centralized access.
+  class ResourceManager
+    class << self
+      attr_accessor :inst
+    end
+
+    def initialize(window)
+      ResourceManager.inst = self
+      @window = window
+      @resources = {}
+      @media_dir = "#{__dir__}/../../media"
+      load_config
+    end
+
+    def media_file_path(media_path)
+      "#{@media_dir}/#{media_path}"
+    end
+
+    def load_config
+      File.open(media_file_path('resource.cfg')).each do |line|
+        cfg = line.split(';').map!(&:strip)
+        next unless cfg.size >= 3
+        case cfg[1]
+        when 'image' then load_image(cfg)
+        when 'animation' then load_animation(cfg)
+        when 'font' then load_font(cfg)
+        when 'sound' then load_sound(cfg)
+        end
+      end
+    end
+
+    def load_animation(cfg)
+      return unless cfg.size >= 7
+
+      sprite = Sprite.new
+      x_offset = cfg[3].to_i
+      y_offset = cfg[4].to_i
+      sprite.width = cfg[5].to_i
+      sprite.height = cfg[6].to_i
+      frames  = cfg[7].to_i
+
+      (0...frames).each do |i|
+        image = Gosu::Image.new(@window, media_file_path(cfg[2]), true,
+                                x_offset + i * sprite.width, y_offset,
+                                sprite.width, sprite.height)
+        sprite.frames.push(image)
+      end
+
+      @resources[cfg[0]] = sprite
+    end
+
+    def load_image(cfg)
+      sprite = Sprite.new
+      sprite.frames.push(Gosu::Image.new(@window, media_file_path(cfg[2]), false))
+      sprite.width = sprite.frames[0].width
+      sprite.height = sprite.frames[0].height
+      @resources[cfg[0]] = sprite
+    end
+
+    def load_sound(cfg)
+      sound = Gosu::Sample.new(@window, media_file_path(cfg[2]))
+      @resources[cfg[0]] = sound
+    end
+
+    def load_font(cfg)
+      begin
+        font = Gosu::Font.new(@window, media_file_path(cfg[2]), cfg[3].to_i)
+        font.text_width('font found test')
+      rescue
+        font = Gosu::Font.new(@window, Gosu::default_font_name, cfg[3].to_i)
+      end
+      @resources[cfg[0]] = font
+    end
+
+    def resource(name)
+      @resources[name]
+    end
+
+    def self.[](resource_name)
+      @inst.resource(resource_name)
+    end
+
+    def self.media(media_path)
+      @inst.media_file_path(media_path)
+    end
+  end
+end

data/lib/ruby_man/sprite.rb

@@ -0,0 +1,26 @@
+require 'ruby_man/resource_manager'
+
+module RubyMan
+  # drawable animated image
+  class Sprite
+    attr_accessor :frames
+    attr_accessor :width, :height
+
+    def initialize
+      @frames = []
+    end
+
+    def self.[](resource_name)
+      ResourceManager[resource_name]
+    end
+
+    def draw(x, y, depth = 0, rotation = 0, frame = 0, scale = 1.0)
+      frames[frame].draw_rot(x + @width / 2, y + @height / 2, -depth,
+                             rotation, 0.5, 0.5, scale, scale)
+    end
+
+    def draw_centered(x, y, depth = 0, rotation = 0, frame = 0, scale = 1.0)
+      frames[frame].draw_rot(x, y, -depth, rotation, 0.5, 0.5, scale, scale)
+    end
+  end
+end

data/lib/ruby_man/version.rb

@@ -0,0 +1,4 @@
+# Common RubyMan namespace
+module RubyMan
+  VERSION = '0.0.2'
+end

data/media/levellist.txt

@@ -0,0 +1,4 @@
+levels/level_1.txt
+levels/level_2.txt
+levels/level_3.txt
+levels/level_4.txt

data/media/levels/level_1.txt

@@ -0,0 +1,19 @@
+/-----------------------\
+|...........:...........|
+|./----\./-----\./----\.|
+|.|    |.|     |.|    |.|
+|.|    |.|     |.|    |.|
+|.L----J.L-----J.L----J.|
+|.......................|
+|.o.o.o.o./-_-\.o.o.o.o.|
+|....:....|GGG|....:....|
+|.o.o.o.o.L---J.o.o.o.o.|
+|.......................|
+|./----\./-----\./----\.|
+|.|    |.|     |.|    |.|
+|.|    |.|     |.|    |.|
+|.L----J.L-----J.L----J.|
+|.......................|
+|.<-------->P<-------->.|
+|:.....................:|
+L-----------------------J

data/media/levels/level_2.txt

@@ -0,0 +1,19 @@
+/-----------------------\
+|:.....................:|
+|./-----\./---\./-----\.|
+|.| /---J.L\ /J.L---\ |.|
+|.| |:.....L-J.....:| |.|
+|.L-J.<-->.....<-->.L-J.|
+|........../_\..........|
+F-------\./JGL\./-------3
+|   G   |.|GGG|.|   G   |
+|       |.L---J.|       |
+F-------J.......L-------3
+|........./\P/\.........|
+|./-\.<---3L-JF--->./-\.|
+|.| |:....|   |....:| |.|
+|.| L---\.| G |./---J |.|
+|.L-----J.|   |.L-----J.|
+|.........L---J.........|
+L-------\...:.../-------J
+        L-------J        

data/media/levels/level_3.txt

@@ -0,0 +1,19 @@
+/-----------T-----------\
+|...........|...........|
+|./--\./--\.|./--\./--\.|
+|:|  |.|  |.|.|  |.|  |:|
+|.L--J.L--J.|.L--J.L--J.|
+|...........:...........|
+|.<--\./\./-_-\./\./-->.|
+|....|.||.| GG|.||.|....|
+F--\.|.||.|GGG|.||.|./--3
+|  |.|.||.L-T-J.||.|.|  |
+F--J.V.LJ...|...LJ.V.L--3
+|.........A.P.A.........|
+|./\./--\.V.|.V./--\./\.|
+|.||.L--3...|...F--J.||.|
+|:||....L->.V.<-J....||:|
+|.|L--\.........../--J|.|
+|.L---J.<>./-\.<>.L---J.|
+|..........| |..........|
+L----------4-4----------J

data/media/levels/level_4.txt

@@ -0,0 +1,19 @@
+/----T-T---------T-T----\
+|...:|G|....:....|G|:...|
+|.<--4_4--->.<---4_4-->.|
+|.......................|
+F----\./-\./-\./-\./----3
+|    |.| |.L-J.| |.|    |
+|    |.| |.....| |.|    |
+F----J.L-J./-\.L-J.L----3
+|..........|G|..........|
+|./--\.<---3 F--->./--\.|
+|.|  |.....L-J.....|  |.|
+|.|  L\./\..P../\./J  |.|
+|.L---J.|L-----J|.L---J.|
+|.......|       |.......|
+|./-\./-J/-----\L-\./-\.|
+|.|G|.|  |.....|  |.|G|.|
+|.L_J.L--J./_\.L--J.L_J.|
+|:.........|G|.........:|
+L----------4-4----------J

data/media/levels/level_empty.txt

@@ -0,0 +1,19 @@
+/-----------------------\
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+|                       |
+L-----------------------J

data/media/resource.cfg

@@ -0,0 +1,18 @@
+rubyman;animation;rubyman_strip11.png;0;0;32;32;11
+walls;animation;walls_strip16.png;0;0;32;32;16
+door;animation;door_strip2.png;0;0;32;32;2
+ghost_left;animation;ghost_left_strip2.png;0;0;32;32;2
+ghost_right;animation;ghost_right_strip2.png;0;0;32;32;2
+ghost_up;animation;ghost_up_strip2.png;0;0;32;32;2
+ghost_down;animation;ghost_down_strip2.png;0;0;32;32;2
+ghost_scared;animation;ghost_scared_strip2.png;0;0;32;32;2
+ghost_stop_scared;animation;ghost_stopscared_strip3.png;0;0;32;32;3
+ghost_death;animation;ghost_death_strip15.png;0;0;32;32;15
+gem;animation;gem_strip9.png;0;0;32;32;9
+logo;image;logo.png
+sfx_begin;sound;sfx/pacman_beginning.wav
+sfx_death;sound;sfx/pacman_death.wav
+sfx_eatghost;sound;sfx/pacman_eatghost.wav
+sfx_eat;sound;sfx/pacman_chomp.wav
+text_normal;font;Arial;22
+text_large;font;Arial;48

data/test/aabb_spec.rb

@@ -0,0 +1,41 @@
+require 'rspec'
+require 'ruby_man/aabb'
+
+# Common RubyMan namespace
+module RubyMan
+  describe 'AABB' do
+    context 'intersection' do
+      subject(:box) { AABB.new(2, 2, 8, 8) }
+      it 'intersects basic cases' do
+        expect(box.intersects?(AABB.new(0, 0, 4, 4))).to be true
+        expect(box.intersects?(AABB.new(4, 4, 10, 10))).to be true
+        expect(box.intersects?(AABB.new(0, 4, 5, 10))).to be true
+        expect(box.intersects?(AABB.new(4, 0, 10, 5))).to be true
+      end
+
+      it 'intersects edges' do
+        expect(box.intersects?(AABB.new(3, 0, 4, 10))).to be true
+        expect(box.intersects?(AABB.new(0, 3, 10, 4))).to be true
+      end
+
+      it 'accepts floats' do
+        expect(box.intersects?(AABB.new(2.1, 0, 7.9, 10))).to be true
+      end
+
+      it 'does not intersect' do
+        expect(box.intersects?(AABB.new(-1000, -1000, 1, 1))).to be false
+        expect(box.intersects?(AABB.new(9, 9, 1000, 1000))).to be false
+        expect(box.intersects?(AABB.new(-1000, -1000, 1000, 1))).to be false
+        expect(box.intersects?(AABB.new(-1000, 9, 1000, 1000))).to be false
+      end
+
+      it 'intersects when contained inside other' do
+        expect(box.intersects?(AABB.new(0, 0, 10, 10))).to be true
+      end
+
+      it 'intersects when containing other' do
+        expect(box.intersects?(AABB.new(4, 4, 5, 5))).to be true
+      end
+    end
+  end
+end

data/test/direction_spec.rb

@@ -0,0 +1,48 @@
+require 'rspec'
+require 'ruby_man/direction'
+
+# Common RubyMan namespace
+module RubyMan
+  describe 'Direction' do
+    context 'should work with Array booleans' do
+      subject(:arr) { [Direction.left, Direction.right, Direction.up] }
+
+      it 'works with intersection' do
+        expect(arr & [Direction.right,
+                      Direction.down,
+                      Direction.up]).to eq [Direction.right, Direction.up]
+      end
+
+      it 'works with subtraction' do
+        expect(arr - [Direction.right,
+                      Direction.down,
+                      Direction.up]).to eq [Direction.left]
+      end
+
+      it 'works with equal' do
+        expect(arr).to eq [Direction.left, Direction.right, Direction.up]
+      end
+    end
+
+    context 'functionality' do
+      subject(:dir) { Direction.up }
+      it { expect(dir).to eq Direction.up }
+      it { expect(dir.opposite).to eq Direction.down }
+      it do
+        expect(dir.inverted).to eq [Direction.right,
+                                    Direction.down,
+                                    Direction.left]
+      end
+      it do
+        expect(Direction.each.to_a).to eq [Direction.right,
+                                           Direction.down,
+                                           Direction.left,
+                                           Direction.up]
+      end
+      it { expect(Direction.each.to_a.map(&:to_i)).to eq [0, 1, 2, 3] }
+      it { expect(Direction.each.to_a.map(&:to_angle)).to eq [0, 90, 180, 270] }
+      it { expect(Direction.each.to_a.map(&:rel_x)).to eq [1, 0, -1, 0] }
+      it { expect(Direction.each.to_a.map(&:rel_y)).to eq [0, 1, 0, -1] }
+    end
+  end
+end

data/test/game_main_spec.rb

@@ -0,0 +1,126 @@
+require 'rspec'
+require 'ruby_man/game_main'
+require 'fileutils'
+
+# Common RubyMan namespace
+module RubyMan
+  describe 'GameMain' do
+    context 'game' do
+      subject(:game) { GameMain.new }
+
+      def select_type(arr, type)
+        arr.select { |obj| obj.is_a?(type) }
+      end
+
+      it 'starts in menu' do
+        expect(select_type(game.objects, Menu).size).to eq 1
+      end
+
+      it 'has at least one level' do
+        expect(game.instance_variable_get(:@levels).size).to be > 0
+      end
+
+      context 'first level' do
+        before { game.start }
+
+        it 'has 3 lives' do
+          expect(game.lives).to eq 3
+        end
+
+        it 'spawns correct number of required game objects' do
+          expect(select_type(game.objects, Player).size).to eq 1
+          expect(select_type(game.moving_objects, Player).size).to eq 1
+          expect(select_type(game.objects, Food).size).to be > 0
+          expect(select_type(game.objects, Hud).size).to eq 1
+          # ghosts aren't mandatory for the game to work
+        end
+
+        it 'spawns player on a free spot' do
+          expect(game.place_free(game.player.grid_x,
+                                 game.player.grid_y)).to be true
+        end
+
+        it 'does not crash after start' do
+          expect { game.update_delta(0.01) }.to_not raise_error
+        end
+
+        it 'sets player variable' do
+          expect(game.player).to be_a Player
+        end
+
+        after { game.main_menu }
+      end
+
+      context 'test level' do
+        def setup
+          level = '|G..:' + "\n" \
+                  'L_P| '
+          game.end_level
+          game.load_level_string(level, false)
+          # verify test sanity - the player should be at (2,1)
+          raise_error unless game.player.grid_x == 2 && game.player.grid_y == 1
+        end
+
+        before { setup }
+
+        it 'player detects walls' do
+          expect(game.player.direction_free(Direction.up)).to be true
+          expect(game.player.direction_free(Direction.left)).to be false
+          expect(game.player.direction_free(Direction.right)).to be false
+        end
+
+        context 'player is killed by ghost' do
+          before do
+            game.lives = 3
+            ghost = game.objects_at(1, 0).first
+            ghost.set_pos(2, 1)
+            # process collision
+            game.update_delta(0)
+            # skip time after pause
+            game.update_delta(2.5)
+            # process level restart
+            game.update_delta(0)
+          end
+
+          it 'reduces player lives' do
+            expect(game.lives).to eq 2
+          end
+
+          after do
+            game.lives = 3
+            setup
+          end
+        end
+
+        context 'ghost' do
+          subject(:ghost) { game.objects_at(1, 0).first }
+
+          before { ghost.change_direction(Direction.up) }
+
+          it 'starts in chase mode' do
+            expect(instance_variable_get(:@scared)).to be_nil
+          end
+
+          it 'knows where it can go' do
+            # down would be turning back, left would be into the wall
+            expect(ghost.possible_directions).to match_array [Direction.right,
+                                                              Direction.up]
+          end
+
+          it 'knows directions to player' do
+            expect(ghost.directions_to_player).to match_array [Direction.right,
+                                                               Direction.down]
+          end
+
+          it 'knows directions in which to run away from player' do
+            expect(ghost.scared_directions).to eq [Direction.up]
+          end
+        end
+
+        after do
+          game.main_menu
+        end
+      end
+    end
+  end
+end