astar_visualizer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 39837dbd735e9048db8a9e1f5a919722b8e6c8acadeee1dd5c40f6bfca756e86
+  data.tar.gz: eca57add44720b859d36dcfd56c632ccf1599286b421306fadacbe3271389ea1
+SHA512:
+  metadata.gz: ce8f2847926c6776c061a2092e661af8f715fc7ac4c14403b9db1cdd609a4878735254f44c98087eb82f5d940bf4a843ea45225a8b34bc75842e90e03cee5c01
+  data.tar.gz: b1ec1e53196d19fe2cb57c9528d9ab9c4f9cd8aff9bbfb29aa4cd18ec5185f8b69f9b2ada4c272e37fcd45e68812f595866a4f2795584d4092a99229a3caaa69

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Quentin DESCHAMPS
+
+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,52 @@
+# A* Visualizer
+
+**A* Visualizer** is an interactive application to visualize the
+[A* pathfinding algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm)
+in a grid with obstacles. The heuristic function used is the
+[Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry).
+
+It uses the [Gosu](https://github.com/gosu/gosu) game development library.
+
+![Demo](https://github.com/Quentin18/astar-visualizer/blob/master/img/demo.gif)
+
+## Install
+To install this ruby gem, use the `gem` command:
+```
+gem install astar_visualizer
+```
+
+## Usage
+To launch the A* Visualizer, use this command:
+```
+astar-visualizer
+```
+
+You can also use the `irb` environment:
+```ruby
+require 'astar_visualizer'
+AStar.new.show
+```
+
+You can also choose the size of the grid:
+```
+astar-visualizer SIZE
+```
+SIZE must be a number between 10 and 100 (default: 50).
+
+It will open a window with the grid. Then:
+
+1. Left click on a node to choose the start node.
+2. Left click on another node to choose the end node.
+3. Left click on nodes to put obstacles. Right click on them if you want to remove them.
+4. Press *ENTER* to launch the A* algorithm. If a path is found, the path is colored in yellow and the visited nodes in cyan.
+5. Press *SUPPR* to clear the window.
+
+## Links
+- GitHub: https://github.com/Quentin18/astar-visualizer
+- RubyGems: https://rubygems.org/gems/astar_visualizer
+
+## Author
+[Quentin Deschamps](mailto:quentindeschamps18@gmail.com)
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)

data/astar_visualizer.gemspec

@@ -0,0 +1,35 @@
+Gem::Specification.new do |s|
+  s.name        = 'astar_visualizer'
+  s.version     = '0.0.1'
+  s.license     = 'MIT'
+  s.summary     = 'A* pathfinding visualizer using Gosu'
+  s.description = <<-DESCRIPTION
+    A* Visualizer is an interactive application to visualize
+    the A* pathfinding algorithm in a grid with obstacles.
+    It uses the Gosu game development library.
+  DESCRIPTION
+  s.author      = 'Quentin Deschamps'
+  s.email       = 'quentindeschamps18@gmail.com'
+  s.homepage    = 'https://github.com/Quentin18/astar-visualizer'
+
+  s.add_runtime_dependency 'gosu', '~> 0.15.2'
+  s.require_paths = ['lib']
+  s.files = [
+    'bin/astar-visualizer',
+    'lib/astar_visualizer.rb',
+    'lib/astar_visualizer/astar.rb',
+    'lib/astar_visualizer/grid.rb',
+    'lib/astar_visualizer/node.rb',
+    'LICENSE',
+    'README.md',
+    'astar_visualizer.gemspec'
+  ]
+
+  s.bindir = 'bin'
+  s.executables << 'astar-visualizer'
+
+  s.rdoc_options = ['--main', 'README.md']
+  s.extra_rdoc_files = ['LICENSE', 'README.md']
+
+  s.post_install_message = 'Thanks for installing! Run this command: astar-visualizer'
+end

data/bin/astar-visualizer

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'astar_visualizer'
+MIN_SIZE = 10
+MAX_SIZE = 100
+
+if ARGV.empty?
+  window = AStar.new
+else
+  size = ARGV.first.to_i
+  if size < MIN_SIZE || size > MAX_SIZE
+    puts "Please choose a size between #{MIN_SIZE} and #{MAX_SIZE}."
+    return
+  end
+  window = AStar.new(size)
+end
+
+window.show

data/lib/astar_visualizer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'astar_visualizer/astar'
+require 'astar_visualizer/grid'
+require 'astar_visualizer/node'

data/lib/astar_visualizer/astar.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+#
+# File: astar.rb
+# Author: Quentin Deschamps
+# Date: August 2020
+#
+
+require 'gosu'
+require 'astar_visualizer/grid'
+
+#
+# The AStar class manages the window with the grid and can launch
+# the A* algorithm.
+#
+class AStar < Gosu::Window
+  # Size of the grid in pixels.
+  SIZE_GRID = 700
+
+  # Height of the informations block in pixels.
+  HEIGHT_INFO_BLOCK = 40
+
+  # Number of squares by lines and columns in the grid.
+  DEFAULT_SIZE = 50
+
+  #
+  # Creates the window with its grid.
+  #
+  def initialize(size=DEFAULT_SIZE)
+    super(SIZE_GRID, SIZE_GRID + HEIGHT_INFO_BLOCK, false)
+    self.caption = 'A* Pathfinding Visualizer'
+    @font = Gosu::Font.new(28)
+    @message = 'Choose the start node.'
+    @grid = Grid.new(self, size, size, SIZE_GRID)
+    @start = @end = nil
+    @needs_reset = false
+  end
+
+  #
+  # To show the mouse cursor on the window.
+  #
+  def needs_cursor?
+    true
+  end
+
+  #
+  # Returns if the A* algorithm can be launched.
+  #
+  def ready?
+    !@needs_reset && @start && @end
+  end
+
+  #
+  # Resets the start node.
+  #
+  def reset_start!
+    @start = nil
+  end
+
+  #
+  # Resets the end node.
+  #
+  def reset_end!
+    @end = nil
+  end
+
+  #
+  # Resets the window.
+  #
+  def reset!
+    reset_start!
+    reset_end!
+    @grid.reset!
+    @needs_reset = false
+  end
+
+  #
+  # Gets the button down. Two different actions:
+  #
+  # * *ENTER*: launch A* algorithm
+  # * *SUPPR*: clear window
+  #
+  def button_down(id)
+    # ENTER: launch A* algorithm
+    if id == Gosu::KbReturn && ready?
+      @grid.update_neighbors
+      a_star
+      @needs_reset = true
+    end
+
+    # SUPPR: clear window
+    reset! if id == Gosu::KbDelete
+  end
+
+  #
+  # Finds the node in the grid corresponding to the mouse position.
+  #
+  def find_node
+    @grid.find_node(self.mouse_x, self.mouse_y)
+  end
+
+  #
+  # Updates the window. If the mouse buttons are used, it updates nodes and
+  # the message in the informations block.
+  #
+  def update
+    return if @needs_reset
+
+    # Message
+    if !@start
+      @message = 'Choose the start node.'
+    elsif !@end
+      @message = 'Choose the end node.'
+    else
+      @message = 'Add obstacles and press ENTER.'
+    end
+
+    if Gosu.button_down? Gosu::MsLeft
+      node = find_node
+      if node
+        # Make start node
+        if !@start && node != @end
+          node.start!
+          @start = node
+        # Make end node
+        elsif !@end && node != @start
+          node.end!
+          @end = node
+        # Make obstacle
+        elsif node != @start && node != @end
+          node.obstacle!
+        end
+      end
+    end
+
+    # Clear a node
+    if Gosu.button_down? Gosu::MsRight
+      node = find_node
+      if node
+        node.reset!
+        if node == @start
+          reset_start!
+        elsif node == @end
+          reset_end!
+        end
+      end
+    end
+  end
+
+  #
+  # Draws the grid and the informations block.
+  #
+  def draw
+    @grid.draw
+    show_info
+  end
+
+  #
+  # Shows the informations block.
+  #
+  def show_info
+    @font.draw_text(@message, 10, SIZE_GRID + 8, 5)
+  end
+
+  #
+  # Reconstructs the path found by coloring the nodes.
+  #
+  def reconstruct_path(came_from, current)
+    while came_from.include?(current)
+      current = came_from[current]
+      current.path!
+    end
+    @start.start!
+    @end.end!
+  end
+
+  #
+  # Launchs the A* algorithm.
+  #
+  def a_star
+    open_set = [@start]
+    came_from = {}
+    g_score = {}
+    f_score = {}
+    @grid.each_node do |node|
+      g_score[node] = Float::INFINITY
+      f_score[node] = Float::INFINITY
+    end
+    g_score[@start] = 0
+    f_score[@start] = h(@start)
+
+    until open_set.empty?
+      current = open_set[0]
+      open_set.each do |node|
+        current = node if f_score[node] < f_score[current]
+      end
+
+      if current == @end
+        reconstruct_path(came_from, current)
+        @message = 'Path found! Press SUPPR to clear the window.'
+        return true
+      end
+
+      current = open_set.delete_at(open_set.index(current))
+
+      current.neighbors.each do |neighbor|
+        tentative_g_score = g_score[current] + 1
+        next if tentative_g_score >= g_score[neighbor]
+
+        came_from[neighbor] = current
+        g_score[neighbor] = tentative_g_score
+        f_score[neighbor] = g_score[neighbor] + h(neighbor)
+        unless open_set.include?(neighbor)
+          open_set << neighbor
+          neighbor.open!
+        end
+      end
+
+      current.closed! if current != @start
+    end
+    @message = 'No path found! Press SUPPR to clear the window.'
+    false
+  end
+
+  #
+  # Heuristic function used : Manhattan distance.
+  #
+  def h(node)
+    (node.x - @end.x).abs + (node.y - @end.y).abs
+  end
+end

data/lib/astar_visualizer/grid.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+#
+# File: grid.rb
+# Author: Quentin Deschamps
+# Date: August 2020
+#
+
+require 'gosu'
+require 'astar_visualizer/node'
+
+#
+# The Grid class represents the grid. It is composed of nodes.
+#
+class Grid
+  #
+  # Builds the nodes of the grid. It returns the list of nodes.
+  #
+  def self.build_nodes(window, cols, rows, width, height)
+    nodes = []
+    rows.times do |y|
+      nodes << []
+      cols.times do |x|
+        nodes[y] << Node.new(window, x, y, width, height)
+      end
+    end
+    nodes
+  end
+
+  #
+  # Creates the grid with the nodes.
+  #
+  def initialize(window, cols, rows, size)
+    @window = window
+    @cols = cols
+    @rows = rows
+    @width = size / cols    # width of a node's square
+    @height = size / rows   # height of a node's square
+    @nodes = Grid.build_nodes(window, cols, rows, @width, @height)
+    @color = Gosu::Color.argb(0xaad3d3d3)
+  end
+
+  #
+  # Returns a node from the grid.
+  #
+  def node(x, y)
+    @nodes[y][x]
+  end
+
+  #
+  # Yields all nodes of the grid.
+  #
+  def each_node
+    @rows.times do |y|
+      @cols.times do |x|
+        yield node(x, y)
+      end
+    end
+  end
+
+  #
+  # Returns if the (x, y) position is in the grid.
+  #
+  def inside?(x, y)
+    x >= 0 && x < @cols && y >= 0 && y < @rows
+  end
+
+  #
+  # Returns if a node is walkable.
+  #
+  def walkable?(x, y)
+    inside?(x, y) && !node(x, y).obstacle?
+  end
+
+  #
+  # Updates the neighbors of all nodes.
+  #
+  def update_neighbors
+    each_node do |node|
+      x = node.x
+      y = node.y
+      node.neighbors.clear
+      node.add_to_neighbors(node(x, y - 1)) if walkable?(x, y - 1)  # ↑
+      node.add_to_neighbors(node(x + 1, y)) if walkable?(x + 1, y)  # →
+      node.add_to_neighbors(node(x, y + 1)) if walkable?(x, y + 1)  # ↓
+      node.add_to_neighbors(node(x - 1, y)) if walkable?(x - 1, y)  # ←
+    end
+  end
+
+  #
+  # Resets all the nodes.
+  #
+  def reset!
+    each_node(&:reset!)
+  end
+
+  #
+  # Draws the lines of the grid.
+  #
+  def draw_grid
+    @rows.times do |i|  # horizontal
+      x1 = 0
+      y1 = @height * i
+      x2 = @width * @cols
+      y2 = @height * i
+      @window.draw_line(x1, y1, @color, x2, y2, @color)
+    end
+    @cols.times do |i|  # vertical
+      x1 = @width * i
+      y1 = 0
+      x2 = @width * i
+      y2 = @height * @rows
+      @window.draw_line(x1, y1, @color, x2, y2, @color)
+    end
+  end
+
+  #
+  # Draws the nodes and the grid.
+  #
+  def draw
+    each_node(&:draw)
+    draw_grid
+  end
+
+  #
+  # Finds a node in the grid using mouse position.
+  #
+  def find_node(mouse_x, mouse_y)
+    each_node do |node|
+      return node if node.inside?(mouse_x, mouse_y)
+    end
+    nil
+  end
+end

data/lib/astar_visualizer/node.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+#
+# File: node.rb
+# Author: Quentin Deschamps
+# Date: August 2020
+#
+
+require 'gosu'
+
+#
+# The Node class represents the squares of the grid.
+#
+class Node
+  # Gets the x position in the grid.
+  attr_reader :x
+
+  # Gets the y position in the grid.
+  attr_reader :y
+
+  # Gets the neighbors (list of nodes).
+  attr_reader :neighbors
+
+  #
+  # Creates a node. It is composed of the (x, y) position in the grid and the
+  # neighbors (list of nodes).
+  #
+  def initialize(window, x, y, width, height)
+    @@colors ||= {
+      green: Gosu::Color.argb(0xff00ff00),
+      red: Gosu::Color.argb(0xffff0000),
+      grey: Gosu::Color.argb(0xff808080),
+      lightcyan: Gosu::Color.argb(0xffe0ffff),
+      cyan: Gosu::Color.argb(0xff00ffff),
+      white: Gosu::Color.argb(0xffffffff),
+      yellow: Gosu::Color.argb(0xffffff00),
+    }
+    @@window ||= window
+    @x = x
+    @y = y
+    @width = width
+    @height = height
+    @color = @@colors[:white]
+    @neighbors = []
+  end
+
+  #
+  # Returns if the node is the start point (green color).
+  #
+  def start?
+    @color == @@colors[:green]
+  end
+
+  #
+  # Makes a node the start point (green color).
+  #
+  def start!
+    @color = @@colors[:green]
+  end
+
+  #
+  # Returns if the node is the end point (red color).
+  #
+  def end?
+    @color == @@colors[:red]
+  end
+
+  #
+  # Makes a node the end point (red color).
+  #
+  def end!
+    @color = @@colors[:red]
+  end
+
+  #
+  # Returns if the node is an obstacle (grey color).
+  #
+  def obstacle?
+    @color == @@colors[:grey]
+  end
+
+  #
+  # Makes a node an obstacle (grey color).
+  #
+  def obstacle!
+    @color = @@colors[:grey]
+  end
+
+  #
+  # Returns if the node is in the open list (cyan color).
+  #
+  def open?
+    @color == @@colors[:cyan]
+  end
+
+  #
+  # Makes a node like in the open list (cyan color).
+  #
+  def open!
+    @color = @@colors[:cyan]
+  end
+
+  #
+  # Returns if the node is in the closed list (lightcyan color).
+  #
+  def closed?
+    @color == @@colors[:lightcyan]
+  end
+
+  #
+  # Makes a node like in the closed list (lightcyan color).
+  #
+  def closed!
+    @color = @@colors[:lightcyan]
+  end
+
+  #
+  # Resets a node (white color).
+  #
+  def reset!
+    @color = @@colors[:white]
+  end
+
+  #
+  # Makes a node in the found path (yellow color).
+  #
+  def path!
+    @color = @@colors[:yellow]
+  end
+
+  #
+  # Draws the square.
+  #
+  def draw
+    @@window.draw_rect(@x * @width, @y * @height, @width, @height, @color)
+  end
+
+  #
+  # Returns if the mouse position is in the square.
+  #
+  def inside?(mouse_x, mouse_y)
+    pos_x = @x * @width
+    pos_y = @y * @height
+    mouse_x >= pos_x && mouse_x <= pos_x + @width && \
+      mouse_y >= pos_y && mouse_y <= pos_y + @height
+  end
+
+  #
+  # Adds a node to the neighbors list.
+  #
+  def add_to_neighbors(node)
+    @neighbors << node
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: astar_visualizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Quentin Deschamps
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.2
+description: |2
+      A* Visualizer is an interactive application to visualize
+      the A* pathfinding algorithm in a grid with obstacles.
+      It uses the Gosu game development library.
+email: quentindeschamps18@gmail.com
+executables:
+- astar-visualizer
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- astar_visualizer.gemspec
+- bin/astar-visualizer
+- lib/astar_visualizer.rb
+- lib/astar_visualizer/astar.rb
+- lib/astar_visualizer/grid.rb
+- lib/astar_visualizer/node.rb
+homepage: https://github.com/Quentin18/astar-visualizer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 'Thanks for installing! Run this command: astar-visualizer'
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: A* pathfinding visualizer using Gosu
+test_files: []