pacmanrb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e685b8744fb557883d2cef49049c68e4b3763a423e5cf91914291943a038d8a
+  data.tar.gz: d5b6e7fe11076ea9a64c2ce67787cfdc010bf60d26cb1683e1e9ede949e37396
+SHA512:
+  metadata.gz: ebb661277be30360ba2d00e4276c1296e263c4b068bbe32199b72c6ec526dd4815f44bb3d17d324eb33c95719bf4d0e0272d5cc3b0e5885de5be5d6341bb7ad3
+  data.tar.gz: 777249d1f917118c266e73e1ea69b24e0fa9f092938cb469fa17c9c1c61a207dc8675352d6effcdda534aa3a7bf63ea566a66a7c6621c2511cb7568792180be5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pando
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Pacman
+
+A Pacman arcade clone built with the [Charming](https://github.com/pandorocks/charming)
+terminal UI framework.
+
+## Screenshots
+<img width="1256" height="1065" alt="image" src="https://github.com/user-attachments/assets/72cc474b-f54d-40aa-b622-6e203251e0ca" />
+
+
+Run it with:
+
+```sh
+bundle exec pacmanrb
+```
+
+## How to play
+
+- **Enter** on the title screen starts a game.
+- Steer with the **arrow keys** or **WASD** — turns are buffered and taken at the
+  next opening, like the arcade.
+- Eat every pellet to clear the level; levels get faster. Power pellets — drawn as cherries — 
+  frighten the ghosts — they turn blue and dithered — so you can eat them for
+  combo bonuses (200/400/800/1600); eaten ghosts race home as floating eyes.
+- The board scales to your terminal. At larger sizes the actors are drawn as
+  half-block sprites: Pac-Man is a circle whose mouth points where he's headed,
+  ghosts get their classic domed-and-scalloped shape.
+- You have 3 lives. Game over shows the top-5 high score table (persisted in
+  SQLite via `db/development.sqlite3`).
+- **r**/**Enter** restarts from the game over screen; **q** quits anywhere;
+  **ctrl+p** opens the command palette.
+
+The four ghosts have distinct brains: one chases you, one ambushes four tiles
+ahead, one wanders randomly, one patrols its corner. They alternate between
+scatter and chase on a timer.
+
+## Development
+
+```sh
+bundle exec rspec                      # full suite (game logic + controllers + views + integration)
+CHARMING_ENV=test bundle exec charming db:migrate   # prepare the test database
+```
+
+Game rules live in plain Ruby under `lib/pacman/arcade/` (no TTY needed to test
+them); the Charming app layer (controllers/views/components) is under `app/`.
+Live game state is held in memory per run — it intentionally does not survive a
+session's JSON serialization; only high scores persist.

data/app/components/board_component.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Pacman
+  # Draws the maze as a grid of blocks. Each maze cell becomes `scale` terminal
+  # rows by `scale * 2` columns, so the board can grow to fill large terminals.
+  class BoardComponent < Charming::Component
+    WALL_STYLE = Charming::UI.style.foreground("#2121de")
+    PELLET_STYLE = Charming::UI.style.foreground("#ffb8ae")
+    CHERRY_STYLE = Charming::UI.style.foreground("#ff2121").bold
+    STEM_STYLE = Charming::UI.style.foreground("#21c821")
+    PLAYER_STYLE = Charming::UI.style.foreground("#ffff00").bold
+    FRIGHTENED_STYLE = Charming::UI.style.foreground("#2121de").bold
+    EATEN_STYLE = Charming::UI.style.foreground("#ffffff")
+    GHOST_STYLES = [
+      Charming::UI.style.foreground("#ff0000").bold,
+      Charming::UI.style.foreground("#ffb8de").bold,
+      Charming::UI.style.foreground("#00ffde").bold,
+      Charming::UI.style.foreground("#ffb847").bold
+    ].freeze
+
+    def render
+      (0...maze.height).flat_map { |row| block_rows(row) }.join("\n")
+    end
+
+    private
+
+    def maze
+      world.maze
+    end
+
+    def scale
+      assigns.fetch(:scale, 1)
+    end
+
+    def cell_width
+      scale * 2
+    end
+
+    def block_rows(row)
+      (0...scale).map do |subrow|
+        (0...maze.width).map { |col| cell(Arcade::Position.new(row: row, col: col), subrow) }.join
+      end
+    end
+
+    def cell(position, subrow)
+      return ghost_cell(position, subrow) if ghost_at(position)
+      return PLAYER_STYLE.render(player_sprite[subrow]) if world.player.position == position
+      return WALL_STYLE.render("#" * cell_width) if maze.wall?(position)
+      return cherry_cell(subrow) if world.pellets.power?(position)
+      return pellet_cell(position, subrow) if middle?(subrow)
+
+      blank
+    end
+
+    def player_sprite
+      @player_sprite ||= Sprites.player(scale: scale, direction: world.player.direction)
+    end
+
+    def pellet_cell(position, _subrow)
+      return PELLET_STYLE.render(".".center(cell_width)) if world.pellets.include?(position)
+
+      blank
+    end
+
+    def cherry_cell(subrow)
+      Sprites.cherry(scale: scale)[subrow].chars.map { |char| cherry_char(char) }.join
+    end
+
+    def cherry_char(char)
+      return char if char == " "
+      return STEM_STYLE.render(char) if char == "│"
+
+      CHERRY_STYLE.render(char)
+    end
+
+    def middle?(subrow)
+      subrow == (scale - 1) / 2
+    end
+
+    def blank
+      " " * cell_width
+    end
+
+    def ghost_cell(position, subrow)
+      ghost = ghost_at(position)
+      return FRIGHTENED_STYLE.render(Sprites.frightened(scale: scale)[subrow]) if ghost.edible?
+      return EATEN_STYLE.render(Sprites.eaten(scale: scale)[subrow]) if ghost.eaten?
+
+      ghost_style(ghost).render(Sprites.ghost(scale: scale)[subrow])
+    end
+
+    def ghost_at(position)
+      world.ghosts.find { |ghost| ghost.position == position }
+    end
+
+    def ghost_style(ghost)
+      GHOST_STYLES.fetch(world.ghosts.index(ghost) % GHOST_STYLES.length)
+    end
+  end
+end

data/app/components/hud_component.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pacman
+  class HudComponent < Charming::Component
+    def render
+      row(
+        text("SCORE #{world.score}", style: theme.title),
+        text("LIVES #{world.lives}", style: theme.warn),
+        text("LEVEL #{world.level}", style: theme.info),
+        text("PELLETS #{world.pellets.remaining}", style: theme.muted),
+        gap: 4
+      )
+    end
+  end
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pacman
+  class ApplicationController < Charming::Controller
+    layout Layouts::ApplicationLayout
+
+    key "ctrl+p", :open_command_palette, scope: :global
+    key "q", :quit, scope: :global
+
+    command "Home" do
+      navigate_to "/"
+    end
+
+    command "Theme", :open_theme_palette
+    command "Close palette", :close_command_palette
+    command "Quit app", :quit
+    command "Game" do
+      navigate_to "/game"
+    end
+    command "GameOver" do
+      navigate_to "/game_over"
+    end
+  end
+end

data/app/controllers/game_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Pacman
+  class GameController < ApplicationController
+    timer :tick, every: 0.12, action: :advance
+
+    key "up", :turn_up, scope: :global
+    key "down", :turn_down, scope: :global
+    key "left", :turn_left, scope: :global
+    key "right", :turn_right, scope: :global
+    key "w", :turn_up, scope: :global
+    key "s", :turn_down, scope: :global
+    key "a", :turn_left, scope: :global
+    key "d", :turn_right, scope: :global
+
+    def show
+      render :show, world: world, palette: command_palette
+    end
+
+    def advance
+      return unless movement_pulse?
+
+      world.tick
+      return finish_game if world.over?
+
+      show
+    end
+
+    def turn_up = turn(Arcade::Direction.up)
+
+    def turn_down = turn(Arcade::Direction.down)
+
+    def turn_left = turn(Arcade::Direction.left)
+
+    def turn_right = turn(Arcade::Direction.right)
+
+    private
+
+    # Skips timer pulses at high zoom so on-screen speed stays playable.
+    def movement_pulse?
+      game.pulse += 1
+      pace = BoardScale.new(screen: screen, maze: world.maze).pace
+      (game.pulse % pace).zero?
+    end
+
+    def finish_game
+      summary = state(:game_over, GameOverState)
+      summary.score = world.score
+      summary.level = world.level
+      HighScore.create!(name: "PLAYER", score: world.score)
+      game.world = nil
+      navigate_to "/game_over"
+    end
+
+    def turn(direction)
+      world.queue_turn(direction)
+      show
+    end
+
+    def world
+      game.world ||= Arcade::World.classic
+    end
+
+    def game
+      state(:game, GameState)
+    end
+  end
+end

data/app/controllers/game_over_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pacman
+  class GameOverController < ApplicationController
+    key "r", :restart, scope: :global
+    key "enter", :restart, scope: :global
+
+    def show
+      render :show,
+        game_over: game_over,
+        high_scores: HighScore.top(5).to_a,
+        palette: command_palette
+    end
+
+    def restart
+      state(:game, GameState).world = nil
+      navigate_to "/game"
+    end
+
+    private
+
+    def game_over
+      state(:game_over, GameOverState)
+    end
+  end
+end

data/app/controllers/home_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pacman
+  class HomeController < ApplicationController
+    key "enter", :start_game, scope: :global
+    key "space", :start_game, scope: :global
+
+    def show
+      render :show, home: home, palette: command_palette
+    end
+
+    def start_game
+      navigate_to "/game"
+    end
+
+    private
+
+    def home
+      state(:home, HomeState)
+    end
+  end
+end

data/app/models/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pacman
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/high_score.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pacman
+  class HighScore < ApplicationRecord
+    scope :top, ->(count) { order(score: :desc).limit(count) }
+  end
+end

data/app/state/application_state.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Pacman
+  class ApplicationState < Charming::ApplicationState
+  end
+end

data/app/state/game_over_state.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pacman
+  class GameOverState < ApplicationState
+    attribute :title, :string, default: "GameOver"
+    attribute :score, :integer, default: 0
+    attribute :level, :integer, default: 1
+  end
+end

data/app/state/game_state.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pacman
+  class GameState < ApplicationState
+    attribute :title, :string, default: "Game"
+    attribute :world
+    attribute :pulse, :integer, default: 0
+  end
+end

data/app/state/home_state.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pacman
+  class HomeState < ApplicationState
+    attribute :title, :string, default: "Pacman"
+  end
+end

data/app/views/game/show_view.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Game
+    class ShowView < Charming::View
+      def render
+        return cramped_notice if board_scale.cramped?
+
+        Charming::UI.center(
+          column(
+            render_component(HudComponent.new(world: world)),
+            render_component(BoardComponent.new(world: world, scale: board_scale.factor)),
+            gap: 1
+          ),
+          width: layout_screen.width,
+          height: layout_screen.height
+        )
+      end
+
+      private
+
+      def board_scale
+        @board_scale ||= BoardScale.new(screen: layout_screen, maze: world.maze)
+      end
+
+      def cramped_notice
+        text "Terminal too small — need at least " \
+          "#{world.maze.width * 2}x#{world.maze.height + BoardScale::HUD_ROWS}.", style: theme.warn
+      end
+    end
+  end
+end

data/app/views/game_over/show_view.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Pacman
+  module GameOver
+    class ShowView < Charming::View
+      def render
+        Charming::UI.center(
+          column(banner, summary, high_score_table, hint, gap: 1),
+          width: layout_screen.width,
+          height: layout_screen.height
+        )
+      end
+
+      private
+
+      def banner
+        text "GAME OVER", style: theme.title.bold
+      end
+
+      def high_score_table
+        return "" if high_scores.empty?
+
+        column(
+          text("HIGH SCORES", style: theme.title),
+          *high_scores.map.with_index(1) do |entry, rank|
+            text("#{rank}. #{entry.name}  #{entry.score}", style: theme.info)
+          end
+        )
+      end
+
+      def summary
+        text "Final score #{game_over.score} · reached level #{game_over.level}", style: theme.info
+      end
+
+      def hint
+        text "Press r or Enter to play again · q to quit", style: theme.muted
+      end
+    end
+  end
+end

data/app/views/home/show_view.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Home
+    class ShowView < Charming::View
+      LOGO = <<~ART
+        ██████╗  █████╗  ██████╗      ███╗   ███╗ █████╗ ███╗   ██╗
+        ██╔══██╗██╔══██╗██╔════╝█████╗████╗ ████║██╔══██╗████╗  ██║
+        ██████╔╝███████║██║     ╚════╝██╔████╔██║███████║██╔██╗ ██║
+        ██╔═══╝ ██╔══██║██║           ██║╚██╔╝██║██╔══██║██║╚██╗██║
+        ██║     ██║  ██║╚██████╗      ██║ ╚═╝ ██║██║  ██║██║ ╚████║
+        ╚═╝     ╚═╝  ╚═╝ ╚═════╝      ╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝
+      ART
+
+      def render
+        Charming::UI.center(
+          column(logo_block, subtitle, start_hint, controls_hint, gap: 1),
+          width: layout_screen.width,
+          height: layout_screen.height
+        )
+      end
+
+      private
+
+      def logo_block
+        text LOGO.chomp, style: theme.title
+      end
+
+      def subtitle
+        text "PAC-MAN — a Charming arcade clone", style: theme.info
+      end
+
+      def start_hint
+        text "Press Enter to start", style: theme.title.bold
+      end
+
+      def controls_hint
+        text "Arrows or WASD to steer · q to quit", style: theme.muted
+      end
+    end
+  end
+end

data/app/views/layouts/application_layout.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Layouts
+    # Full-bleed layout: the game owns the whole terminal. No sidebar, no
+    # borders — just the screen content with the command palette overlaid.
+    class ApplicationLayout < Charming::View
+      def render
+        screen_layout(background: theme.background) do
+          pane(:content, grow: 1) do
+            yield_content
+          end
+
+          overlay command_palette_modal if command_palette_modal
+        end
+      end
+
+      private
+
+      def palette_component
+        assigns.fetch(:palette, nil)
+      end
+
+      def command_palette_modal
+        return unless palette_component
+
+        render_component Charming::Components::CommandPaletteModal.new(
+          content: palette_component,
+          theme: theme
+        )
+      end
+    end
+  end
+end

data/config/database.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "fileutils"
+
+# The database file is selected by CHARMING_ENV (development, test, production).
+environment = ENV["CHARMING_ENV"] || "development"
+database_path = File.expand_path("../db/#{environment}.sqlite3", __dir__)
+FileUtils.mkdir_p(File.dirname(database_path))
+
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: database_path
+)

data/config/routes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Pacman::Application.routes do
+  root "home#show"
+  screen "/game", to: "game#show", title: "Game"
+  screen "/game_over", to: "game_over#show", title: "GameOver"
+end

data/db/migrate/20260719010011_create_high_scores.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CreateHighScores < ActiveRecord::Migration[8.1]
+  def change
+    create_table :high_scores do |t|
+      t.string :name
+      t.integer :score
+      t.timestamps
+    end
+  end
+end

data/db/schema.rb

@@ -0,0 +1,20 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema[8.1].define(version: 2026_07_19_010011) do
+  create_table "high_scores", force: :cascade do |t|
+    t.datetime "created_at", null: false
+    t.string "name"
+    t.integer "score"
+    t.datetime "updated_at", null: false
+  end
+end

data/db/seeds.rb

@@ -0,0 +1 @@
+# frozen_string_literal: true

data/exe/pacmanrb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "pacman"
+
+Charming.run(Pacman::Application.new)

data/lib/pacman/application.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pacman
+  class Application < Charming::Application
+    root File.expand_path("../..", __dir__)
+
+    Charming::UI::Theme.built_in_names.each do |theme_name|
+      theme theme_name.to_sym, built_in: theme_name
+    end
+
+    default_theme :phosphor
+  end
+end

data/lib/pacman/arcade/brains.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pacman
+  module Arcade
+    # Each brain answers one question: where should this ghost head right now?
+    module Brains
+      class Chase
+        def target(world)
+          world.player.position
+        end
+      end
+
+      class Ambush
+        LOOKAHEAD = 4
+
+        def target(world)
+          player = world.player
+          LOOKAHEAD.times.reduce(player.position) { |spot, _| spot.step(player.direction) }
+        end
+      end
+
+      class Corner
+        def initialize(corner:)
+          @corner = corner
+        end
+
+        def target(_world)
+          @corner
+        end
+      end
+
+      class Wander
+        def initialize(rng:)
+          @rng = rng
+        end
+
+        def target(world)
+          Position.new(
+            row: @rng.rand(world.maze.height),
+            col: @rng.rand(world.maze.width)
+          )
+        end
+      end
+    end
+  end
+end