pacmanx 1.0.1

data/lib/pacman/ghosts_renderer.rb

@@ -0,0 +1,70 @@
+module Pacman
+  # ghosts viewer
+  class GhostsRenderer
+    def initialize(window, rel_path = '')
+      @blinky = { left: Gosu::Image.load_tiles(window, rel_path + 'media/blinky_left.png',
+                                               50, 50, false),
+                  right: Gosu::Image.load_tiles(window, rel_path + 'media/blinky_right.png',
+                                                50, 50, false),
+                  up: Gosu::Image.load_tiles(window, rel_path + 'media/blinky_up.png',
+                                             50, 50, false),
+                  down: Gosu::Image.load_tiles(window, rel_path + 'media/blinky_down.png',
+                                               50, 50, false)
+      }
+
+      @pinky = { left: Gosu::Image.load_tiles(window, rel_path + 'media/pinky_left.png',
+                                              50, 50, false),
+                 right: Gosu::Image.load_tiles(window, rel_path + 'media/pinky_right.png',
+                                               50, 50, false),
+                 up: Gosu::Image.load_tiles(window, rel_path + 'media/pinky_up.png',
+                                            50, 50, false),
+                 down: Gosu::Image.load_tiles(window, rel_path + 'media/pinky_down.png',
+                                              50, 50, false)
+      }
+
+      @inky = { left: Gosu::Image.load_tiles(window, rel_path + 'media/inky_left.png',
+                                             50, 50, false),
+                right: Gosu::Image.load_tiles(window, rel_path + 'media/inky_right.png',
+                                              50, 50, false),
+                up: Gosu::Image.load_tiles(window, rel_path + 'media/inky_up.png',
+                                           50, 50, false),
+                down: Gosu::Image.load_tiles(window, rel_path + 'media/inky_down.png',
+                                             50, 50, false)
+      }
+
+      @clyde = { left: Gosu::Image.load_tiles(window, rel_path + 'media/clyde_left.png',
+                                              50, 50, false),
+                 right: Gosu::Image.load_tiles(window, rel_path + 'media/clyde_right.png',
+                                               50, 50, false),
+                 up: Gosu::Image.load_tiles(window, rel_path + 'media/clyde_up.png',
+                                            50, 50, false),
+                 down: Gosu::Image.load_tiles(window, rel_path + 'media/clyde_down.png',
+                                              50, 50, false)
+      }
+    end
+
+    def render(level, _state, next_frame)
+      if next_frame
+        ghosts = level.ghosts
+        [ghosts[:blinky], ghosts[:pinky], ghosts[:inky], ghosts[:clyde]].each do |ghost|
+          ghost.animation_index = (ghost.animation_index + 1) % @blinky[:left].size
+        end
+      end
+
+      # render ghosts
+      render_ghost(level.ghosts[:blinky], @blinky)
+      render_ghost(level.ghosts[:pinky], @pinky)
+      render_ghost(level.ghosts[:inky], @inky)
+      render_ghost(level.ghosts[:clyde], @clyde)
+    end
+
+    private
+
+    def render_ghost(ghost_model, ghost_graphics)
+      x = LevelRenderer.x_min + ghost_model.x * LevelRenderer.field_size
+      y = LevelRenderer.y_min + ghost_model.y * LevelRenderer.field_size
+      ghost_graphics[ghost_model.direction][ghost_model.animation_index]
+        .draw(x, y, 1)
+    end
+  end
+end

data/lib/pacman/level.rb

@@ -0,0 +1,62 @@
+module Pacman
+  # main model class
+  class Level
+    def initialize
+      resize(0, 0)
+      @player = nil
+      @pellet_count = 0
+      @pellets_left = 0
+      @ghosts = {}
+      @ghosts_frozen = 0
+    end
+
+    def resize(width, height)
+      @width = width
+      @height = height
+
+      # resize array
+      @rows = []
+
+      0.upto(height - 1) do
+        row = []
+        0.upto(width - 1) do
+          row << nil
+        end
+        @rows << row
+      end
+    end
+
+    def [](key)
+      @rows[key]
+    end
+
+    def []=(key, value)
+      @rows[key] = value
+    end
+
+    def get(x, y)
+      @rows[y][x]
+    end
+
+    def each
+      return @rows.each unless block_given?
+      @rows.each do |row|
+        yield row
+      end
+    end
+
+    def register_player(_player)
+    end
+
+    def each_with_position
+      @rows.each_with_index do |row, y|
+        row.each_with_index do |col, x|
+          yield x, y, col
+        end
+      end
+    end
+
+    attr_accessor :width, :height, :player, :pellet_count, :pellets_left,
+                  :cage_obj, :ghosts, :ghosts_frozen
+  end
+end

data/lib/pacman/level_builder.rb

@@ -0,0 +1,129 @@
+
+require_relative 'level'
+require_relative 'animated_object'
+require_relative 'player'
+require_relative 'wall'
+require_relative 'pellet'
+require_relative 'cage'
+require_relative 'ghost'
+
+module Pacman
+  # DSL builder
+  class LevelBuilder
+    class << self
+      def build(dsl)
+        builder = new(dsl)
+        builder.level
+      end
+
+      private :new
+    end
+
+    # builds a level according to the DSL
+    def initialize(dsl)
+      @level = Level.new
+      @x = 0
+      @y = 0
+
+      # exec DSL
+      instance_eval(dsl)
+
+      # place ghosts to the cage
+      if @level.cage_obj
+        cage_obj = @level.cage_obj
+        @level.ghosts = { blinky: BlinkyGhost.new(cage_obj.x, cage_obj.y, :left),
+                          pinky: PinkyGhost.new(cage_obj.x + 1, cage_obj.y,
+                                                :left),
+                          inky: InkyGhost.new(cage_obj.x + 2, cage_obj.y, :right),
+                          clyde: ClydeGhost.new(cage_obj.x + 3, cage_obj.y,
+                                                :right) }
+      end
+
+      @level.pellets_left = @level.pellet_count
+
+      @level
+    end
+
+    def resize(width, height)
+      @level.resize(width, height)
+    end
+
+    def check_bounds(x, y)
+      fail OutOfBoundsError.new if x < 0 || y < 0 || @level.width < x ||
+          @level.height < y
+    end
+
+    # skip n columns if possible, otherwise skip row
+    def skip(n)
+      x = (@x + n) % @level.width
+      y = (@y * @level.width + @x + n) / @level.width
+      fail OutOfBoundsError.new if y >= @level.height || x >= @level.width
+
+      @y = y
+      @x = x
+    end
+
+    # go to specified position
+    def goto(x, y)
+      fail OutOfBoundsError.new if y < 0 || x < 0 || y >= @level.height ||
+          x >= @level.width
+      @x, @y = x, y
+    end
+
+    def place_object(clazz)
+      check_bounds(@x, @y)
+      @level[@y][@x] = clazz.new
+      begin
+        skip(1)
+      rescue
+        raise OutOfBoundsError.new unless @x == @level.width - 1 &&
+              @y == @level.height - 1
+      end
+    end
+
+    def wall
+      place_object(Wall)
+    end
+
+    def pellet
+      place_object(Pellet)
+      @level.pellet_count += 1
+    end
+
+    def power_pellet
+      place_object(PowerPellet)
+    end
+
+    # set player position
+    def player(direction)
+      check_bounds(@x, @y)
+      player = Player.new(direction, @x, @y)
+      level.player = player
+      begin
+        skip(1)
+      rescue
+        raise OutOfBoundsError.new unless @x == @level.width - 1 &&
+          @y == @level.height - 1
+      end
+    end
+
+    def cage
+      check_bounds(@x, @y)
+      cage_obj = Cage.new(@x, @y)
+      @level[@y][@x] = cage_obj
+      begin
+        skip(1)
+      rescue
+        raise OutOfBoundsError.new unless @x == @level.width - 1 &&
+            @y == @level.height - 1
+      end
+
+      @level.cage_obj = cage_obj
+    end
+
+    attr_reader :level
+  end
+
+  class OutOfBoundsError < StandardError
+  end
+end

data/lib/pacman/level_renderer.rb

@@ -0,0 +1,100 @@
+module Pacman
+  # main renderer class
+  class LevelRenderer
+    class << self
+      def field_size
+        50
+      end
+
+      def x_min
+        50
+      end
+
+      def y_min
+        50
+      end
+    end
+
+    def initialize(window, rel_path = '')
+      @ghosts_renderer = GhostsRenderer.new(window, rel_path)
+
+      # initialize graphics
+      @font = Gosu::Font.new(window, 'Arial', 18)
+
+      @field_size = 50
+      @background = Gosu::Image.new(window, rel_path + 'media/bg2_2.jpg', false)
+      @wall = Gosu::Image.new(window, rel_path + 'media/wall.png')
+      @pellet = Gosu::Image.new(window, rel_path + 'media/pellet.png')
+      @power_pellet = Gosu::Image.new(window, rel_path + 'media/power_pellet.png')
+
+      @player_left = Gosu::Image.load_tiles(window, rel_path + 'media/pacman_left.png',
+                                            50, 50, false)
+      @player_right = Gosu::Image.load_tiles(window, rel_path + 'media/pacman_right.png',
+                                             50, 50, false)
+      @player_up = Gosu::Image.load_tiles(window, rel_path + 'media/pacman_up.png',
+                                          50, 50, false)
+      @player_down = Gosu::Image.load_tiles(window, rel_path + 'media/pacman_down.png',
+                                            50, 50, false)
+
+      @timer = 0
+    end
+
+    def render(level, state)
+      @timer += 1
+
+      next_frame = @timer % 5 == 0
+      if next_frame
+        level.player.animation_index = (level.player.animation_index + 1) %
+            @player_down.size
+      end
+
+      @background.draw(0, 0, 0)
+
+      render_objects(level, state)
+
+      # draw player
+      x_pos = LevelRenderer.x_min + level.player.x * LevelRenderer.field_size
+      y_pos = LevelRenderer.y_min + level.player.y * LevelRenderer.field_size
+
+      @ghosts_renderer.render(level, state, next_frame)
+
+      case level.player.direction
+      when :left
+        @player_left[level.player.animation_index].draw(x_pos, y_pos, 1)
+      when :right
+        @player_right[level.player.animation_index].draw(x_pos, y_pos, 1)
+      when :up
+        @player_up[level.player.animation_index].draw(x_pos, y_pos, 1)
+      when :down
+        @player_down[level.player.animation_index].draw(x_pos, y_pos, 1)
+      end
+
+      return unless (state == :win)
+
+      @font.draw('END', 100, 100, 1.0, 4.0, 4.0)
+      score = level.pellet_count - level.pellets_left
+      @font.draw("Score: #{score} / #{level.pellet_count}",
+                 100, 150, 1.0, 1.5, 1.5)
+    end
+
+    private
+
+    def render_objects(level, _state)
+      level.each_with_position do |x, y, obj|
+        x_pos = LevelRenderer.x_min + x * LevelRenderer.field_size
+        y_pos = LevelRenderer.y_min + y * LevelRenderer.field_size
+
+        case
+        when obj.class == Wall
+          @wall.draw(x_pos, y_pos, 1)
+        when obj.class == Pellet
+          @pellet.draw(x_pos, y_pos, 1)
+        when obj.class == PowerPellet
+          @power_pellet.draw(x_pos, y_pos, 1)
+        end
+      end
+
+      return if level.ghosts.empty?
+    end
+  end
+end

data/lib/pacman/levels/level1.lvl

@@ -0,0 +1,98 @@
+resize 20, 11
+
+21.times{ wall }
+power_pellet
+3.times{ pellet }
+wall
+8.times{ pellet }
+wall
+3.times { pellet }
+power_pellet
+2.times{ wall }
+
+pellet
+2.times{ wall }
+pellet
+wall
+pellet
+6.times{ wall }
+pellet
+wall
+pellet
+2.times{ wall }
+pellet
+2.times{ wall }
+
+pellet
+wall
+14.times{ pellet }
+wall
+pellet
+2.times{ wall }
+
+pellet
+wall
+pellet
+2.times{wall}
+pellet
+# skip 6
+6.times{ wall }
+pellet
+2.times{ wall }
+pellet
+wall
+pellet
+2.times{ wall }
+
+6.times{ pellet }
+# skip 6
+skip 1
+cage
+skip 4
+6.times{ pellet }
+2.times{ wall }
+
+pellet
+wall
+pellet
+2.times{ wall }
+pellet
+6.times{ wall }
+pellet
+2.times{ wall }
+pellet
+wall
+pellet
+2.times{ wall }
+
+pellet
+wall
+14.times{ pellet }
+wall
+pellet
+2.times{ wall }
+
+pellet
+2.times{ wall }
+pellet
+wall
+pellet
+6.times{ wall }
+pellet
+wall
+pellet
+2.times{ wall }
+pellet
+2.times{ wall }
+
+power_pellet
+3.times{ pellet }
+wall
+player :right
+7.times{ pellet }
+wall
+3.times{ pellet }
+power_pellet
+wall
+
+20.times{ wall }