a_maze_ing 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 358455708afc8984eb3c53cd4a2379ff01163ad6
-  data.tar.gz: 787780722056a3509e45ac5cdea12ab500048310
+  metadata.gz: ac2d90d1b404af1a23d3c15aa56ba2b43980a053
+  data.tar.gz: 16c989a33c190aa047ea29d4e3e1a4edac58678d
 SHA512:
-  metadata.gz: 051fbc907631bd8fa8320d595347d1fd80e09aab014cb088fdd68073b112043dfc771efe33bfe86b5c5d467641adba2fa5cf456cdaee3dd3d5570d6f19d7f7fc
-  data.tar.gz: 3c5570b4297e01c6e05990287235be693cca65bcf14f1b1c895b678ce06e753931c0a3418bed5b6d7e20050ac6b80a36c9cc7abe64db174b69e6044f3e25355b
+  metadata.gz: 2869dfccd82fe6eb394db5e1b2c80a79d97a35de8263baf0405f0a7fe611383ffc58aa8ae89d84fb3ae7f0b1d85e5a1f0560e968e26d390d648b2aa3d984e880
+  data.tar.gz: b61f4b49474ef300ea74daeed71aad0eac7ff8a17910cbc2e3c106447e3b1aecfce1aae3c2a5c0c3462197c547756eb570284e3c90651704d1cb22d2d1c7ef89

data/lib/a_maze_ing/cell.rb

@@ -11,9 +11,16 @@ module AMazeIng
       @is_current = false
     end
 
+    # cell_index is the index in cells array
+    # cell_index_x and cell_index_y are index of cells in vitual grid
+
+    # Get cell_index by cell_index_x and cell_index_y
+    # if the given indexes is invalid (outside the maze) 
+    # it will return cells_length, 
+    # which will cause the returned cell (neighbor) to be equal to nil
     def cell_index(i, j, cells_length)
       if i < 0 || j < 0 || i > $cols-1 || j > $rows-1
-        return cells_length # cause the cell (neighbor) equal nil
+        return cells_length # cause the cell to be (neighbor) equal to nil
       else
         return i + j * $cols
       end
@@ -22,10 +29,10 @@ module AMazeIng
     def get_random_neighbor(cells)
       @neigh_bors = Array.new
 
-      top    = cells[cell_index(cell_index_x, cell_index_y - 1, cells.length)]
-      right  = cells[cell_index(cell_index_x + 1, cell_index_y, cells.length)]
-      bottom = cells[cell_index(cell_index_x, cell_index_y + 1, cells.length)]
-      left   = cells[cell_index(cell_index_x - 1, cell_index_y, cells.length)]
+      top    = cells[cell_index(cell_index_x,     cell_index_y - 1, cells.length)]
+      right  = cells[cell_index(cell_index_x + 1, cell_index_y,     cells.length)]
+      bottom = cells[cell_index(cell_index_x,     cell_index_y + 1, cells.length)]
+      left   = cells[cell_index(cell_index_x - 1, cell_index_y,     cells.length)]
 
       if top
         if !top.visited
@@ -65,23 +72,23 @@ module AMazeIng
       y = @cell_index_y * cell_size
 
       if @walls[0] 
-        draw_line x, y, color,
-                  x + cell_size, y, color
+        draw_line x,             y,             color,
+                  x + cell_size, y,             color
       end
 
       if @walls[1] 
-        draw_line x + cell_size, y, color,
+        draw_line x + cell_size, y,             color,
                   x + cell_size, y + cell_size, color
       end
 
       if @walls[2] 
         draw_line x + cell_size, y + cell_size, color,
-                  x, y + cell_size, color
+                  x,             y + cell_size, color
       end
 
       if @walls[3] 
-        draw_line x, y + cell_size, color,
-                  x, y, color
+        draw_line x,             y + cell_size, color,
+                  x,             y,             color
       end
     end
   end

data/lib/a_maze_ing/cli.rb

@@ -41,7 +41,7 @@ module AMazeIng
 
       command :annoying_friend do |c|
         c.syntax = 'a_maze_ing anfri [options]'
-        c.description = 'feuded friend mode, player 1 try to get to the gate while the player 2(annoying friend) try to catch him'
+        c.description = 'Annoying friend mode, player 1 try to get to the gate while the player 2(annoying friend) try to catch him'
         c.action do 
             AMazeIng::GameWindow.new(@full_screen,3).show
         end

data/lib/a_maze_ing/game_window.rb

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# cGREENits to: http://en.wikipedia.org/wiki/Maze_generation_algorithm
 
 require 'gosu'
 include Gosu
@@ -8,15 +7,28 @@ require "observer"
 module AMazeIng
   DIMENSION = 700
   SIDE_BAR = 180
+  ROWS = COLS = 10
   PLAYER_COLOR_PRIMARY = Color::GREEN
   PLAYER_COLOR_SECONDARY = Color::AQUA
   PLAYER_COLOR_ANGRY = Color::RED
+
+  # the rate of character speed, in pixel, 
+  # the higher step rate the slower character will move
+  STEP_RATE = 4
+  
+
+  # Change this if you don't want it to be at bottom right
+  TARGET_CELL_INDEX_X = COLS - 1
+  TARGET_CELL_INDEX_Y = ROWS - 1
+
   class GameWindow < Window
-    $rows = $cols = 10
+    $rows = $cols = ROWS
     def initialize(full_screen, game_mode)
       @game_mode = game_mode
       super DIMENSION + SIDE_BAR, DIMENSION, full_screen, 30
       self.caption = "Maze"
+
+      
       
       #---------------------------------------------------------------------------------#
       # create code block (update, player_draw and new_player) for different game mode  #
@@ -88,7 +100,11 @@ module AMazeIng
         @infor = Infor.new(PLAYER_COLOR_PRIMARY, PLAYER_COLOR_ANGRY)
       end
 
-    end
+      @target_x = (TARGET_CELL_INDEX_X * $cell_size) + $cell_size/2 - $player_size/2
+      @target_y = (TARGET_CELL_INDEX_Y * $cell_size) + $cell_size/2 - $player_size/2
+
+    end # End initialize function
+    
 
     def new_round
       $rows += 2
@@ -99,14 +115,10 @@ module AMazeIng
     end
 
     def draw_target(cell)
-      cell_index_x = cell.cell_index_x
-      cell_index_y = cell.cell_index_y
-      x = (cell_index_x * $cell_size) + $cell_size/2 - $player_size/2
-      y = (cell_index_y * $cell_size) + $cell_size/2 - $player_size/2
-      draw_quad x, y, Color::WHITE,
-                x+$player_size, y, Color::WHITE,
-                x+$player_size, y+$player_size, Color::WHITE,
-                x, y+$player_size, Color::WHITE
+      draw_quad @target_x,                @target_y,                Color::WHITE,
+                @target_x + $player_size, @target_y,                Color::WHITE,
+                @target_x + $player_size, @target_y + $player_size, Color::WHITE,
+                @target_x,                @target_y + $player_size, Color::WHITE
     end
 
     def check_for_finish(player)

data/lib/a_maze_ing/infor.rb

@@ -4,6 +4,7 @@ module AMazeIng
     def initialize(*player_color)
       @player_color = player_color
 
+      # This class will renders information of the game, like points and level
 
       #---------------------------------------------------------------------------------#
       # create code block (initial, update and draw) for different game mode            #
@@ -15,6 +16,7 @@ module AMazeIng
         
           @level = 1
           @level_image = Gosu::Image.from_text @level.to_s, 36
+          
           @label = 'LEVEL'
           @label_image = Gosu::Image.from_text @label, 40
           

data/lib/a_maze_ing/maze.rb

@@ -1,23 +1,33 @@
+# Credits to: http://en.wikipedia.org/wiki/Maze_generation_algorithm
+# I use Depth-first search recursive backtracking algorithm
+# You can find the information in the wiki link
+
 module AMazeIng
   class Maze
 
+    # This is very important.
+    # With this calculated dimension 
+    # the character will be exactly at the pixel you want it to be 
     def check_dimension
-      until $dimension/$cols % 4 == 0
+      until $dimension/$cols % STEP_RATE == 0
         $dimension -= 1
       end
     end
     
     def generate_maze
+
+      # set initial specifications for the maze
       $dimension = DIMENSION
       check_dimension
       $cell_size = $dimension/$cols
-      $speed_per_tick = $cell_size/4
+      $speed_per_tick = $cell_size/STEP_RATE
       $player_size = 0.5 * $cell_size
 
       $cells = Array.new
       @stack = Array.new
       
-
+      # I use one dimensional array to store all the cell... 
+      # yeah, should not do that... feel regret now
       $rows.times do |row_index|
         $cols.times do |col_index|
           cell = Cell.new(col_index, row_index)
@@ -25,11 +35,15 @@ module AMazeIng
         end
       end
 
+      # Ok, here is where the heavy work begin
+      # Let set visited for the top left cell, where we start
       $cells[0].visited = true
       @current_cell = $cells[0]
       # @current_cell.is_current = true
       @stack.push(@current_cell)
 
+      # This is the same as "While there are unvisited cells"
+      # at least, same result, see the wiki page for more
       while @stack.length > 0 do 
         next_cell = @current_cell.get_random_neighbor($cells)
         if next_cell
@@ -43,37 +57,42 @@ module AMazeIng
           @current_cell = @stack.pop
         end
       end
+
+      # Remove more random walls to make more available way
       remove_extra_walls 
     end
 
     def remove_walls(current_cell, next_cell)
       if next_cell != nil
+
+        # yeah I'd like to call it magic_number
+        # it show me the relative position of two cell
         magic_number =  next_cell.cell_index_x - current_cell.cell_index_x
-        if magic_number == 1
-          # next cell is on the right
+        
+        if magic_number == 1 # next cell is on the right
           current_cell.walls[1] = next_cell.walls[3] = false
-        elsif magic_number == -1
-          # next cell is on the left
+
+        elsif magic_number == -1 # next cell is on the left
           current_cell.walls[3] = next_cell.walls[1] = false
-        elsif magic_number == 0
-          # next cell is either on top or bottom
+
+        elsif magic_number == 0 # next cell is either on top or bottom
           magic_number = next_cell.cell_index_y - current_cell.cell_index_y
-          if magic_number == 1
-            #next cell is bottom
+
+          if magic_number == 1 #next cell is bottom
             current_cell.walls[2] = next_cell.walls[0] = false
-          elsif magic_number ==-1
-            #next cell is on top
+
+          elsif magic_number ==-1#next cell is on top
             current_cell.walls[0] = next_cell.walls[2] = false
           end
         end
       end
     end
 
+    # For now, it almost doesn't remove horizontal walls
     def remove_extra_walls
       a_count_number = $cells.length/2/5
       while a_count_number > 0 do
         cell_index = rand(0..$cells.length/2)
-        # wall_index = rand(0..3)
         remove_walls($cells[cell_index], $cells[cell_index+1])
         a_count_number -= 1
       end

data/lib/a_maze_ing/player.rb

@@ -49,12 +49,13 @@ module AMazeIng
     def move
       if @is_moving
         if @x == @target_x && @y == @target_y
+          
           # check for available path, 
-          # and ignore the the opposite of the LAST path 
+          # and ignore the the opposite directions of the LAST path 
           # cuz you don't wanna go back where you just left
           @path = check_for_path(@path == 0 ? 2:
-                                @path == 1 ? 3:
-                                @path == 2 ? 0: 1)
+                                 @path == 1 ? 3:
+                                 @path == 2 ? 0: 1)
           if @path != nil
             # set new player's cell index depend on "current @path"
             set_status(@path)
@@ -85,10 +86,10 @@ module AMazeIng
     end
 
     def draw
-      draw_quad @x, @y, @color,
-                @x+$player_size, @y, @color,
-                @x+$player_size, @y+$player_size, @color,
-                @x, @y+$player_size, @color
+      draw_quad @x,                @y,                @color,
+                @x + $player_size, @y,                @color,
+                @x + $player_size, @y + $player_size, @color,
+                @x,                @y + $player_size, @color
     end
   end
 end

data/lib/a_maze_ing/version.rb

@@ -1,3 +1,3 @@
 module AMazeIng
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: a_maze_ing
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - at-cuongtran