RubyMan 0.0.2

data/lib/ruby_man/GameObjects/moving_object.rb

@@ -0,0 +1,50 @@
+require 'ruby_man/GameObjects/grid_object'
+require 'ruby_man/direction'
+
+module RubyMan
+  # GridObject with the ability to move smoothly in 4 directions
+  class MovingObject < GridObject
+    attr_accessor :direction, :phase, :speed
+
+    def initialize
+      super
+      @direction = Direction.none
+      @phase = 0
+      @speed = 0
+    end
+
+    def update(delta)
+      super
+      @phase += @speed * delta
+      while @phase > 1
+        @phase -= 1
+        @grid_x += @direction.rel_x
+        @grid_y += @direction.rel_y
+        grid_step
+      end
+    end
+
+    def grid_step
+    end
+
+    def collision(_other)
+    end
+
+    def change_direction(direction)
+      @direction = direction
+      @image_angle = direction.to_angle
+    end
+
+    def direction_free(direction)
+      @game.place_free(@grid_x + direction.rel_x, @grid_y + direction.rel_y)
+    end
+
+    def pixel_x
+      (@grid_x + @direction.rel_x * @phase) * 32
+    end
+
+    def pixel_y
+      (@grid_y + @direction.rel_y * @phase) * 32
+    end
+  end
+end

data/lib/ruby_man/GameObjects/player.rb

@@ -0,0 +1,90 @@
+require 'gosu'
+require 'ruby_man/GameObjects/moving_object'
+require 'ruby_man/GameObjects/food'
+require 'ruby_man/GameObjects/ghost'
+require 'ruby_man/GameObjects/door'
+
+module RubyMan
+  # player (RubyMan) object
+  class Player < MovingObject
+    def created
+      self.sprite = Sprite['rubyman']
+      @image_speed = 3
+      @next_direction = Direction.none
+      @speed = 3
+      @is_dead = false
+      @game.player = self
+    end
+
+    def button_down(id)
+      case id
+      when Gosu::KbLeft then @next_direction = Direction.left
+      when Gosu::KbUp then @next_direction = Direction.up
+      when Gosu::KbRight then @next_direction = Direction.right
+      when Gosu::KbDown then @next_direction = Direction.down
+      end
+    end
+
+    def update(delta)
+      dead if @is_dead
+      super
+    end
+
+    def grid_step
+      eat_food
+      change_direction(@next_direction)
+      @direction = Direction.none unless direction_free(@direction)
+    end
+
+    def direction_free(direction)
+      x = @grid_x + direction.rel_x
+      y = @grid_y + direction.rel_y
+      @game.objects_at(x, y).each do |obj|
+        return false if obj.solid || obj.is_a?(Door)
+      end
+      true
+    end
+
+    def collision(obj)
+      return unless obj.is_a?(Ghost)
+      return unless distance_to(obj) <= 16
+      if obj.scared?
+        obj.die
+      else
+        die
+      end
+    end
+
+    def die
+      ResourceManager['sfx_death'].play
+      @game.pause(2000)
+      @is_dead = true
+    end
+
+    def dead
+      if @game.lives > 0
+        @game.lives -= 1
+        @game.restart
+      else
+        @game.game_over
+      end
+    end
+
+    def eat_food
+      @game.objects_at(@grid_x, @grid_y).each do |obj|
+        next unless obj.is_a?(Food)
+        obj.destroy
+        @game.score += 10
+      end
+    end
+
+    def change_direction(direction)
+      dir_x = @grid_x + direction.rel_x
+      dir_y = @grid_y + direction.rel_y
+      @game.objects_at(dir_x, dir_y).each do |obj|
+        return if obj.solid || obj.is_a?(Door)
+      end
+      super
+    end
+  end
+end

data/lib/ruby_man/GameObjects/super_food.rb

@@ -0,0 +1,16 @@
+require 'ruby_man/GameObjects/food'
+
+module RubyMan
+  # food that makes ghosts vulnerable
+  class SuperFood < Food
+    def created
+      super
+      @scale = 1
+    end
+
+    def destroyed
+      super
+      @game.moving_objects.select { |obj| obj.is_a?(Ghost) }.each(&:scare)
+    end
+  end
+end

data/lib/ruby_man/GameObjects/wall.rb

@@ -0,0 +1,24 @@
+require 'ruby_man/GameObjects/grid_object'
+
+module RubyMan
+  # impassable wall
+  class Wall < GridObject
+    def initialize(type)
+      super()
+      self.sprite = Sprite['walls']
+      @image_index = type
+      @image_speed = 0
+      @solid = true
+    end
+
+    def self.chars
+      '+T34F/\\JL-|oAV<>'
+    end
+
+    def self.from_char(char)
+      index = chars.index(char)
+      return if index.nil?
+      Wall.new(index)
+    end
+  end
+end

data/lib/ruby_man/aabb.rb

@@ -0,0 +1,17 @@
+module RubyMan
+  # Axis-Aligned Bounding Box
+  class AABB
+    attr_reader :x_beg, :y_beg
+    attr_reader :x_end, :y_end
+
+    def initialize(x_beg, y_beg, x_end, y_end)
+      @x_beg, @y_beg = x_beg, y_beg
+      @x_end, @y_end = x_end, y_end
+    end
+
+    def intersects?(other)
+      @x_beg < other.x_end && @x_end > other.x_beg &&
+        @y_beg < other.y_end && @y_end > other.y_beg
+    end
+  end
+end

data/lib/ruby_man/direction.rb

@@ -0,0 +1,102 @@
+module RubyMan
+  # Class representing left/right/up/down/none direction in 2D space
+  class Direction
+    def initialize(dir = :none)
+      @direction = dir
+    end
+
+    def self.none
+      Direction.new
+    end
+
+    def self.left
+      Direction.new(:left)
+    end
+
+    def self.right
+      Direction.new(:right)
+    end
+
+    def self.up
+      Direction.new(:up)
+    end
+
+    def self.down
+      Direction.new(:down)
+    end
+
+    def self.each
+      return to_enum unless block_given?
+      yield Direction.right
+      yield Direction.down
+      yield Direction.left
+      yield Direction.up
+    end
+
+    def to_i
+      case @direction
+      when :right
+        return 0
+      when :down
+        return 1
+      when :left
+        return 2
+      when :up
+        return 3
+      end
+    end
+
+    def self.from_i(num)
+      case num % 4
+      when 0
+        return Direction.right
+      when 1
+        return Direction.down
+      when 2
+        return Direction.left
+      when 3
+        return Direction.up
+      end
+    end
+
+    def rel_x
+      i = to_i
+      return 0 unless i
+      (1 - i) * ((i + 1) % 2)
+    end
+
+    def rel_y
+      i = to_i
+      return 0 unless i
+      (2 - i) * (i % 2)
+    end
+
+    def opposite
+      i = to_i
+      return Direction.none unless i
+      Direction.from_i(to_i + 2)
+    end
+
+    def inverted
+      Direction.each.select { |dir| dir != self }
+    end
+
+    def to_angle
+      i = to_i
+      return 0 unless i
+      i * 90
+    end
+
+    def ==(other)
+      to_i == other.to_i
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      @direction.hash
+    end
+  end
+end

data/lib/ruby_man/game_main.rb

@@ -0,0 +1,213 @@
+require 'gosu'
+require 'ruby_man/resource_manager'
+require 'ruby_man/level_loader'
+require 'ruby_man/GameObjects/menu'
+require 'ruby_man/GameObjects/game_over'
+
+module RubyMan
+  # Game window and the game itself
+  class GameMain < Gosu::Window
+    include LevelLoader
+
+    attr_reader :x_res, :y_res
+    attr_accessor :lives, :score
+    attr_reader :scores
+    attr_accessor :player
+    attr_reader :objects, :moving_objects
+
+    def initialize
+      @x_res, @y_res = 800, 640
+      super(@x_res, @y_res, false)
+      @resmgr = ResourceManager.new(self)
+      @objects, @moving_objects = [], []
+      @last_milliseconds = Gosu.milliseconds
+      @food_left = 0
+      @pause_time = -0.5
+      self.caption = 'RubyMan'
+      load_scores
+      load_level_list
+      main_menu
+    end
+
+    def load_scores
+      @config_file_name = "#{Dir.home}/.rubyman.cfg"
+      @scores = []
+      @score = 0
+      return unless File.exist?(@config_file_name)
+      File.open(@config_file_name).each do |line|
+        entry = line.strip.split(';')
+        entry[2] = entry[2].to_i
+        @scores.push(entry)
+      end
+    end
+
+    def save_scores
+      file = File.open("#{Dir.home}/.rubyman.cfg", 'w')
+      count = 0
+      @scores.each do |entry|
+        count += 1
+        break if count > 10
+        line = "#{entry[0]};#{entry[1]};#{entry[2]}"
+        file.puts(line)
+      end
+    end
+
+    def add_score(name)
+      entry = [name, Time.new.strftime('%Y-%m-%d %H:%M'), @score]
+      @scores.push(entry)
+      sort_scores
+      save_scores
+    end
+
+    def sort_scores
+      @scores.sort! do |a, b|
+        a[2] <=> b[2]
+      end
+      @scores.reverse!
+      @scores = @scores.first(10)
+    end
+
+    def load_level_list
+      @levels = []
+      @level = 0
+      File.open(ResourceManager.media('levellist.txt')).each do |line|
+        @levels.push(line.strip)
+      end
+    end
+
+    def start
+      @lives = 3
+      @score = 0
+      @level = -1
+      next_level
+    end
+
+    def restart
+      persistent = @objects.select { |obj| obj.class.persistent }
+      persistent_moving = @moving_objects.select { |obj| obj.class.persistent }
+      load_level(@level, true)
+      @objects += persistent
+      @moving_objects += persistent_moving
+      pause(1000)
+    end
+
+    def next_level
+      if @level < @levels.size - 1
+        @level += 1
+        load_level(@level, false)
+        ResourceManager['sfx_begin'].play
+        pause(3000)
+      else
+        game_over
+      end
+    end
+
+    def end_level
+      @objects.clear
+      @moving_objects.clear
+    end
+
+    def load_level(num, restart)
+      end_level
+      load_level_file(@levels[num], restart)
+    end
+
+    def level_loaded
+      # reevaluate ghost directions after level is fully loaded
+      moving_objects.each { |obj| obj.select_direction! if obj.is_a?(Ghost) }
+    end
+
+    def game_over
+      end_level
+      add_object(GameOver.new)
+    end
+
+    def main_menu
+      end_level
+      add_object(Menu.new)
+    end
+
+    def add_object(obj)
+      @objects.push(obj)
+      obj.game = self
+      @moving_objects.push(obj) if obj.is_a?(MovingObject)
+      obj.created
+    end
+
+    def destroy_object(obj)
+      obj.destroyed
+      @objects.delete(obj)
+      @moving_objects.delete(obj) if obj.is_a?(MovingObject)
+    end
+
+    def button_down(id)
+      close if id == Gosu::KbEscape
+      pause if id == Gosu::KbSpace
+      @objects.each { |obj| obj.button_down(id) }
+    end
+
+    def pause(ms = -1000.0)
+      if paused
+        @pause_time = -0.5
+      else
+        @pause_time = ms / 1000.0
+      end
+    end
+
+    def paused
+      return true if @pause_time > 0 || @pause_time == -1
+      false
+    end
+
+    def update
+      current_time = Gosu.milliseconds / 1000.0
+      delta = [current_time - @last_milliseconds, 0.25].min
+      @last_milliseconds = current_time
+
+      update_delta(delta)
+    end
+
+    def update_delta(delta)
+      @pause_time -= delta if @pause_time > 0
+
+      return if paused
+      @objects.each { |obj| obj.update(delta) }
+      check_collisions
+    end
+
+    def draw
+      super
+      @objects.each(&:draw)
+    end
+
+    def check_collisions
+      @moving_objects.each do |obj1|
+        bbox = obj1.bbox
+        @moving_objects.each do |obj2|
+          obj2.collision(obj1) if bbox.intersects?(obj2.bbox)
+        end
+      end
+    end
+
+    def place_free(x, y)
+      objects_at(x, y).each { |obj| return false if obj.solid }
+      true
+    end
+
+    def objects_at(x, y)
+      @objects.select do |obj|
+        next unless obj.is_a?(GridObject)
+        obj.grid_x == x && obj.grid_y == y
+      end
+    end
+
+    def food_created
+      @food_left += 1
+    end
+
+    def food_destroyed
+      @food_left -= 1
+      next_level if @food_left == 0
+    end
+  end
+end