pacmanrb 0.1.1

data/lib/pacman/arcade/direction.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    Direction = Data.define(:dy, :dx) do
+      def self.up = @up ||= new(dy: -1, dx: 0)
+
+      def self.down = @down ||= new(dy: 1, dx: 0)
+
+      def self.left = @left ||= new(dy: 0, dx: -1)
+
+      def self.right = @right ||= new(dy: 0, dx: 1)
+
+      def self.all = [up, down, left, right]
+
+      def opposite = Direction.new(dy: -dy, dx: -dx)
+    end
+  end
+end

data/lib/pacman/arcade/ghost.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class Ghost
+      attr_reader :position, :direction
+
+      def initialize(spawn:, brain:, direction: Direction.up)
+        @spawn = spawn
+        @brain = brain
+        @direction = direction
+        @position = spawn.start
+        @state = :normal
+      end
+
+      def advance(world)
+        @direction = choose_direction(world)
+        @position = world.maze.wrap(position.step(@direction))
+        revive if eaten? && position == spawn.start
+      end
+
+      def frighten
+        @state = :frightened unless eaten?
+      end
+
+      def calm
+        @state = :normal unless eaten?
+      end
+
+      def devour
+        @state = :eaten
+      end
+
+      def edible?
+        @state == :frightened
+      end
+
+      def eaten?
+        @state == :eaten
+      end
+
+      def respawn
+        @position = spawn.start
+        @direction = Direction.up
+        @state = :normal
+      end
+
+      private
+
+      attr_reader :spawn, :brain
+
+      def choose_direction(world)
+        if edible?
+          world.navigator.wander(from: position, current: direction, rng: world.rng)
+        else
+          world.navigator.toward(target: target(world), from: position, current: direction)
+        end
+      end
+
+      def target(world)
+        return spawn.start if eaten?
+        return spawn.corner if world.mode == :scatter
+
+        brain.target(world)
+      end
+
+      def revive
+        @state = :normal
+      end
+    end
+  end
+end

data/lib/pacman/arcade/layouts.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    # ASCII maze layouts. Legend: `#` wall, `.` pellet, `o` power pellet,
+    # `P` player start, `G` ghost start, space = open corridor (no pellet).
+    # A row whose first and last cells are open is a wrap-around tunnel row.
+    module Layouts
+      CLASSIC = <<~MAZE
+        ###################
+        #o.......#.......o#
+        #.##.###.#.###.##.#
+        #.................#
+        #.##.#.#####.#.##.#
+        #....#.GGGG..#....#
+        #.##.#.#####.#.##.#
+         .................
+        #.##.#.#####.#.##.#
+        #....#...#...#....#
+        #.##.###.#.###.##.#
+        #........P........#
+        #.##.###.#.###.##.#
+        #o...#.......#...o#
+        ###################
+      MAZE
+    end
+  end
+end

data/lib/pacman/arcade/maze.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class Maze
+      attr_reader :width, :height
+
+      def initialize(layout)
+        @rows = pad_rows(layout.lines.map(&:chomp))
+        @height = @rows.length
+        @width = @rows.first.length
+      end
+
+      def pellet_positions
+        positions_of(".")
+      end
+
+      def power_positions
+        positions_of("o")
+      end
+
+      def open_neighbors(position)
+        Direction.all.map { |direction| wrap(position.step(direction)) }
+          .reject { |neighbor| wall?(neighbor) }
+      end
+
+      def player_start
+        positions_of("P").first
+      end
+
+      def ghost_starts
+        positions_of("G")
+      end
+
+      def wrap(position)
+        Position.new(row: position.row % height, col: position.col % width)
+      end
+
+      def wall?(position)
+        cell(position) == "#"
+      end
+
+      private
+
+      def cell(position)
+        rows[position.row][position.col]
+      end
+
+      def positions_of(marker)
+        each_position.select { |position| cell(position) == marker }
+      end
+
+      def each_position
+        (0...height).to_a.product((0...width).to_a).map do |row, col|
+          Position.new(row: row, col: col)
+        end
+      end
+
+      attr_reader :rows
+
+      def pad_rows(lines)
+        widest = lines.map(&:length).max
+        lines.map { |line| line.ljust(widest) }
+      end
+    end
+  end
+end

data/lib/pacman/arcade/mode_schedule.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class ModeSchedule
+      attr_reader :mode
+
+      def initialize(scatter_ticks:, chase_ticks:, frightened_ticks:)
+        @durations = {scatter: scatter_ticks, chase: chase_ticks}
+        @frightened_ticks = frightened_ticks
+        @mode = :scatter
+        @remaining = scatter_ticks
+        @frightened_remaining = 0
+      end
+
+      def frighten!
+        @paused_mode = mode unless frightened?
+        @mode = :frightened
+        @frightened_remaining = @frightened_ticks
+      end
+
+      def frightened?
+        mode == :frightened
+      end
+
+      def tick
+        return tick_frightened if frightened?
+
+        advance_cycle
+        nil
+      end
+
+      private
+
+      def tick_frightened
+        @frightened_remaining -= 1
+        return nil if @frightened_remaining.positive?
+
+        @mode = @paused_mode
+        :frightened_ended
+      end
+
+      def advance_cycle
+        @remaining -= 1
+        return if @remaining.positive?
+
+        @mode = (mode == :scatter) ? :chase : :scatter
+        @remaining = @durations.fetch(@mode)
+      end
+    end
+  end
+end

data/lib/pacman/arcade/navigator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class Navigator
+      def initialize(maze)
+        @maze = maze
+      end
+
+      def toward(target:, from:, current:)
+        candidates(from, current).min_by do |choice|
+          maze.wrap(from.step(choice)).distance_sq(target)
+        end
+      end
+
+      def wander(from:, current:, rng:)
+        options = candidates(from, current)
+        options[rng.rand(options.length)]
+      end
+
+      private
+
+      attr_reader :maze
+
+      def candidates(from, current)
+        open = open_directions(from)
+        forward = open - [current.opposite]
+        forward.empty? ? open : forward
+      end
+
+      def open_directions(from)
+        Direction.all.reject { |choice| maze.wall?(maze.wrap(from.step(choice))) }
+      end
+    end
+  end
+end

data/lib/pacman/arcade/pellet_field.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class PelletField
+      def initialize(pellets:, powers:)
+        @pellets = pellets.to_set
+        @powers = powers.to_set
+      end
+
+      def eat(position)
+        return :pellet if pellets.delete?(position)
+        return :power if powers.delete?(position)
+
+        nil
+      end
+
+      def empty?
+        remaining.zero?
+      end
+
+      def remaining
+        pellets.size + powers.size
+      end
+
+      def include?(position)
+        pellets.include?(position) || powers.include?(position)
+      end
+
+      def power?(position)
+        powers.include?(position)
+      end
+
+      private
+
+      attr_reader :pellets, :powers
+    end
+  end
+end

data/lib/pacman/arcade/player.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class Player
+      attr_reader :position, :direction
+
+      def initialize(position:, direction:)
+        @start = position
+        @initial_direction = direction
+        @position = position
+        @direction = direction
+      end
+
+      def respawn
+        @position = @start
+        @direction = @initial_direction
+        @queued_turn = nil
+      end
+
+      def queue_turn(new_direction)
+        @queued_turn = new_direction
+      end
+
+      def advance(maze)
+        apply_queued_turn(maze)
+        ahead = maze.wrap(position.step(direction))
+        @position = ahead unless maze.wall?(ahead)
+      end
+
+      private
+
+      def apply_queued_turn(maze)
+        return unless @queued_turn
+        return if maze.wall?(maze.wrap(position.step(@queued_turn)))
+
+        @direction = @queued_turn
+        @queued_turn = nil
+      end
+    end
+  end
+end

data/lib/pacman/arcade/position.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    Position = Data.define(:row, :col) do
+      def step(direction)
+        Position.new(row: row + direction.dy, col: col + direction.dx)
+      end
+
+      def distance_sq(other)
+        ((row - other.row)**2) + ((col - other.col)**2)
+      end
+    end
+  end
+end

data/lib/pacman/arcade/scoreboard.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    class Scoreboard
+      PELLET_POINTS = 10
+      POWER_POINTS = 50
+      FIRST_GHOST_BONUS = 200
+
+      attr_reader :total
+
+      def initialize
+        @total = 0
+        reset_combo
+      end
+
+      def pellet!
+        award(PELLET_POINTS)
+      end
+
+      def power!
+        award(POWER_POINTS)
+      end
+
+      def ghost!
+        bonus = award(@next_ghost_bonus)
+        @next_ghost_bonus *= 2
+        bonus
+      end
+
+      def reset_combo
+        @next_ghost_bonus = FIRST_GHOST_BONUS
+      end
+
+      private
+
+      def award(points)
+        @total += points
+        points
+      end
+    end
+  end
+end

data/lib/pacman/arcade/spawn.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    # Where a ghost lives: its starting cell and the corner it retreats to in scatter mode.
+    Spawn = Data.define(:start, :corner)
+  end
+end

data/lib/pacman/arcade/world.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    # The aggregate root: owns every actor and advances the whole game one tick
+    # at a time. As the composition root it accepts the full cast — the wide
+    # keyword list is deliberate and isolated behind the .classic factory.
+    class World
+      GHOST_STRIDE = 2
+      FRIGHTENED_STRIDE = 3
+      STARTING_LIVES = 3
+
+      attr_reader :maze, :player, :pellets, :ghosts, :navigator, :rng, :lives, :level
+
+      def self.classic(rng: Random.new)
+        maze = Maze.new(Layouts::CLASSIC)
+        new(
+          maze: maze,
+          player: Player.new(position: maze.player_start, direction: Direction.left),
+          pellets: PelletField.new(pellets: maze.pellet_positions, powers: maze.power_positions),
+          scoreboard: Scoreboard.new,
+          ghosts: classic_ghosts(maze, rng),
+          schedule: ModeSchedule.new(scatter_ticks: 40, chase_ticks: 120, frightened_ticks: 50),
+          rng: rng
+        )
+      end
+
+      def self.classic_ghosts(maze, rng)
+        corners = [
+          Position.new(row: 1, col: maze.width - 2),
+          Position.new(row: 1, col: 1),
+          Position.new(row: maze.height - 2, col: maze.width - 2),
+          Position.new(row: maze.height - 2, col: 1)
+        ]
+        brains = [Brains::Chase.new, Brains::Ambush.new, Brains::Wander.new(rng: rng), nil]
+        maze.ghost_starts.each_with_index.map do |start, index|
+          corner = corners.fetch(index % corners.length)
+          Ghost.new(
+            spawn: Spawn.new(start: start, corner: corner),
+            brain: brains.fetch(index % brains.length) || Brains::Corner.new(corner: corner)
+          )
+        end
+      end
+
+      def initialize(maze:, player:, pellets:, scoreboard:, ghosts: [], schedule: nil, rng: Random.new)
+        @maze = maze
+        @player = player
+        @pellets = pellets
+        @scoreboard = scoreboard
+        @ghosts = ghosts
+        @schedule = schedule
+        @rng = rng
+        @navigator = Navigator.new(maze)
+        @lives = STARTING_LIVES
+        @level = 1
+        @ticks = 0
+      end
+
+      def over?
+        lives <= 0
+      end
+
+      def tick
+        return [] if over?
+
+        @ticks += 1
+        events = []
+        events.concat(advance_schedule)
+        player.advance(maze)
+        events.concat(eat_at(player.position))
+        events.concat(resolve_collisions)
+        return events if events.include?(:death)
+
+        advance_ghosts
+        events.concat(resolve_collisions)
+      end
+
+      def queue_turn(direction)
+        player.queue_turn(direction)
+      end
+
+      def score
+        scoreboard.total
+      end
+
+      def mode
+        schedule ? schedule.mode : :chase
+      end
+
+      private
+
+      attr_reader :scoreboard, :schedule
+
+      EATEN_EVENTS = {pellet: :pellet_eaten, power: :power_pellet}.freeze
+
+      def eat_at(position)
+        kind = pellets.eat(position)
+        return [] unless kind
+
+        scoreboard.public_send(:"#{kind}!")
+        frighten_all if kind == :power
+        events = [EATEN_EVENTS.fetch(kind)]
+        events.concat(clear_level) if pellets.empty?
+        events
+      end
+
+      def clear_level
+        @level += 1
+        @pellets = PelletField.new(pellets: maze.pellet_positions, powers: maze.power_positions)
+        player.respawn
+        ghosts.each(&:respawn)
+        [:level_clear]
+      end
+
+      def frighten_all
+        schedule&.frighten!
+        ghosts.each(&:frighten)
+        scoreboard.reset_combo
+      end
+
+      def advance_schedule
+        return [] unless schedule
+        return [] unless schedule.tick == :frightened_ended
+
+        ghosts.each(&:calm)
+        scoreboard.reset_combo
+        [:frightened_ended]
+      end
+
+      def advance_ghosts
+        ghosts.each { |ghost| ghost.advance(self) if moves_this_tick?(ghost) }
+      end
+
+      def moves_this_tick?(ghost)
+        (@ticks % stride(ghost)).zero?
+      end
+
+      def stride(ghost)
+        base = (level == 1) ? GHOST_STRIDE : 1
+        ghost.edible? ? base + 1 : base
+      end
+
+      def resolve_collisions
+        ghosts.select { |ghost| ghost.position == player.position }
+          .flat_map { |ghost| resolve_collision(ghost) }
+      end
+
+      def resolve_collision(ghost)
+        return [] if ghost.eaten?
+        return devour(ghost) if ghost.edible?
+
+        death
+      end
+
+      def devour(ghost)
+        ghost.devour
+        scoreboard.ghost!
+        [:ghost_eaten]
+      end
+
+      def death
+        @lives -= 1
+        player.respawn
+        ghosts.each(&:respawn)
+        [:death]
+      end
+    end
+  end
+end

data/lib/pacman/board_scale.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pacman
+  # How much the board is zoomed for a given terminal, and how that zoom slows
+  # the game's movement pace so on-screen speed stays roughly constant.
+  class BoardScale
+    HUD_ROWS = 2
+
+    def initialize(screen:, maze:)
+      @screen = screen
+      @maze = maze
+    end
+
+    def factor
+      [width_factor, height_factor].min
+    end
+
+    def cramped?
+      factor < 1
+    end
+
+    SLOWDOWN_ZOOM = 3
+
+    # Timer pulses per movement tick: full speed at modest zooms, one gentle
+    # halving once cells get big enough that motion would blur across the board.
+    def pace
+      (factor >= SLOWDOWN_ZOOM) ? 2 : 1
+    end
+
+    private
+
+    attr_reader :screen, :maze
+
+    def width_factor
+      screen.width / (maze.width * 2)
+    end
+
+    def height_factor
+      (screen.height - HUD_ROWS) / maze.height
+    end
+  end
+end