pentix 1.0.0

data/README.md

@@ -0,0 +1,29 @@
+# Pentix In Ruby
+
+Pentix is a morally superior Siberian version of the good old tetris game.
+It uses `5x5` matrix and a collection of 29 advanced figures.
+
+And yes, they won't allow you to operate a battle bear until you reach at
+least level 15 in this game :)
+
+
+## Usage
+
+You'll need `Ruby` and `gem install gosu`, after that just run
+the `pentix.rb` file in the console
+
+
+## The Purpose
+
+This project is made solely for educational and self-training purposes.
+Also, as an example for the [gosu](http://code.google.com/p/gosu) gem.
+
+
+## License & Copyright
+
+All the source code and media files in this project are released
+under the terms of the
+[Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License](http://creativecommons.org/licenses/by-nc-sa/3.0/)
+
+Copyright (C) 2011 Nikolay Nemshilov
+

data/bin/pentix

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'pentix.rb'))
+Game.new.show

data/lib/block.rb

@@ -0,0 +1,20 @@
+#
+# A simple block to be used in the figures and the glass
+#
+# Copyright (C) 2011 Nikolay Nemshilov
+#
+class Block
+  attr_accessor :color, :size
+
+  SIZE = 20 # block size in pixels
+  FILE = File.join(File.dirname(__FILE__), '..', 'media', 'block.png')
+
+  def initialize(window, color)
+    @@img ||= Image.new(window, FILE, true)
+    @color = color
+  end
+
+  def draw(x, y)
+    @@img.draw(x * SIZE, y * SIZE, 0, 1.0, 1.0, @color)
+  end
+end

data/lib/controls.rb

@@ -0,0 +1,24 @@
+#
+# And here we handle the controls
+#
+# Copyright (C) 2011 Nikolay Nemshilov
+#
+class Controls
+
+  BUTTONS = {
+    :quit       => Button::KbQ,
+    :reset      => Button::KbEscape,
+    :drop       => Button::KbSpace,
+    :left       => Button::KbLeft,
+    :right      => Button::KbRight,
+    :turn_left  => Button::KbUp,
+    :turn_right => Button::KbDown
+  }.freeze
+
+  def command_for(button)
+    BUTTONS.each do |key, value|
+      return key if button === value
+    end
+  end
+
+end

data/lib/figure.rb

@@ -0,0 +1,155 @@
+#
+# The figure unit. It handles the figure basics, like drawing itself
+# making all sorts of manipulations like movements and rotations,
+# plus it keeps the track of it's position and distance below
+#
+# Copyright (C) 2011 Nikolay Nemshilov
+#
+class Figure
+  attr_accessor :name, :color, :matrix, :pos_x, :pos_y, :distance
+
+  #
+  # Basic constructor
+  #
+  # NOTE! creates a random figure if there is no explicit config
+  #
+  def initialize(window, name=nil)
+    name  ||= FIGURES.keys.shuffle[0]
+    config  = FIGURES[name].split('|')
+
+    @pos_x  = 0
+    @pos_y  = 0
+
+    @name   = name
+    @window = window
+    @color  = COLORS[config.pop.to_sym]
+    @block  = Block.new(window, @color)
+
+    @matrix = config.map{ |row| row.split('').map{|c| c == 'x'}}
+
+    # getting rid of empty colls and rows
+    @matrix.reject!{ |row| row.none? }
+
+    while @matrix.map{ |row| row.last }.none?
+      @matrix.each{ |row| row.pop }
+    end
+  end
+
+  #
+  # Draws the blocks of the figure
+  #
+  def draw
+    @matrix.each_with_index do |row, y|
+      row.each_with_index do |visible, x|
+        @block.draw(@pos_x + x, @pos_y + y) if visible
+      end
+    end
+  end
+
+  def size_x
+    @matrix[0].size
+  end
+
+  def size_y
+    @matrix.size
+  end
+
+  def drop
+    @window.glass.glue_in(self)
+    @window.show_next_figure
+  end
+
+  def move_to(x, y)
+    try_set(@matrix, x, y)
+  end
+
+  def move_left
+    move_to(@pos_x - 1, @pos_y)
+  end
+
+  def move_right
+    move_to(@pos_x + 1, @pos_y)
+  end
+
+  def move_down
+    move_to(@pos_x, @pos_y + 1)
+  end
+
+  def turn_left
+    new_matrix = (0..size_x-1).map do |i|
+      @matrix.map{ |row| row[size_x - 1 - i] }
+    end
+
+    try_set(new_matrix, @pos_x, @pos_y)
+  end
+
+  def turn_right
+    new_matrix = (0..size_x-1).map do |i|
+      @matrix.map{ |row| row[i] }.reverse
+    end
+
+    try_set(new_matrix, @pos_x, @pos_y)
+  end
+
+protected
+
+  def try_set(matrix, pos_x, pos_y)
+    # adjusting x-position for tall figures
+    if matrix != @matrix
+      offset = (size_x - matrix[0].size).abs/2
+      pos_x += offset * (size_x > matrix[0].size ? 1 : -1)
+    end
+
+    if @window.glass.has_space_for?(matrix, pos_x, pos_y)
+      @pos_x    = pos_x
+      @pos_y    = pos_y
+      @matrix   = matrix
+
+      @distance = @window.glass.spaces_below(self)
+    end
+  end
+
+  FIGURES = {
+    :cross     => ' x   |xxx  | x   |     |white',
+    :stairs    => 'x    |xx   | xx  |     |yellow',
+    :batch     => 'x x  |xxx  |     |     |purple',
+    :l_kuckan  => 'xxx  | x   | x   |     |yellow',
+    :s_kuckan  => 'xxx  | x   |     |     |yellow',
+    :l_corner  => 'x    |x    |xxx  |     |white',
+    :s_corner  => 'x    |xx   |     |     |white',
+    :l_square  => 'xx   |xx   |     |     |blue',
+    :s_square  => 'x    |     |     |     |blue',
+    :l_cap     => ' xx  |xxx  |     |     |blue',
+    :r_cap     => 'xx   |xxx  |     |     |blue',
+    :l_peris   => 'xx   | x   | xx  |     |green',
+    :r_peris   => ' xx  | x   |xx   |     |purple',
+    :l_zigota  => 'x    |xxx  | x   |     |green',
+    :r_zigota  => '  x  |xxx  | x   |     |cyan',
+    :ll_worm   => 'xx   | xxx |     |     |green',
+    :lr_worm   => '  xx |xxx  |     |     |cyan',
+    :sl_worm   => 'xx   | xx  |     |     |green',
+    :sr_worm   => ' xx  |xx   |     |     |cyan',
+    :l_crutch  => 'x    |xx   |x    |x    |white',
+    :r_crutch  => ' x   |xx   | x   | x   |yellow',
+    :sl_hook   => 'xxx  |x    |     |     |cyan',
+    :sr_hook   => 'x    |xxx  |     |     |white',
+    :ll_hook   => 'xxxx |x    |     |     |cyan',
+    :lr_hook   => 'x    |xxxx |     |     |yellow',
+    :t_stick   => 'xx   |     |     |     |red',
+    :s_stick   => 'xxx  |     |     |     |red',
+    :l_stick   => 'xxxx |     |     |     |red',
+    :h_stick   => 'xxxxx|     |     |     |red'
+  }.freeze
+
+  COLORS = {
+    :cyan   => 0xFF00F7F1,
+    :blue   => 0xFF0000FF,
+    :orange => 0xFFF69F00,
+    :yellow => 0xFFEAF800,
+    :green  => 0xFF00FF00,
+    :purple => 0xFFB200F8,
+    :red    => 0xFFFE0000,
+    :white  => 0xFFFFFFFF
+  }.freeze
+
+end

data/lib/finish.rb

@@ -0,0 +1,85 @@
+#
+# The Game-Over screen
+#
+# Copyright (C) 2011 Nikolay Nemshilov
+#
+class Finish
+  WIDTH     = 27
+  HEIGHT    = 27
+
+  BG_COLOR  = Color::BLACK
+
+  OVER_FONT = ['Courier',     Block::SIZE * 4, Color::RED].freeze
+  HEAD_FONT = ['Courier',     Block::SIZE + 5, Color::GRAY].freeze
+  TEXT_FONT = ['Courier New', Block::SIZE, Color::GRAY].freeze
+
+  X_OFFSET  = 3.5 * Block::SIZE
+
+  #
+  # Basic constructor
+  #
+  def initialize(window)
+    @window = window
+    @block  = Block.new(window, BG_COLOR)
+
+    @over_font  = Font.new(window, OVER_FONT[0], OVER_FONT[1])
+    @head_font  = Font.new(window, HEAD_FONT[0], HEAD_FONT[1])
+    @text_font  = Font.new(window, TEXT_FONT[0], TEXT_FONT[1])
+
+    @text_input = TextInput.new
+
+    reset!
+  end
+
+  def draw
+    # rendering the black background
+    (0..WIDTH).each do |x|
+      (0..HEIGHT).each do |y|
+        @block.draw(x, y)
+      end
+    end
+
+    @over_font.draw("GAME OVAR!",
+      X_OFFSET, 2 * Block::SIZE,
+      0, 1.0, 1.0, OVER_FONT[2])
+
+    @head_font.draw("Hiscores: ",
+      X_OFFSET, 7 * Block::SIZE,
+      0, 1.0, 1.0, HEAD_FONT[2])
+
+    score = @score.to_s
+    text  = @text_input.text.slice(0, 32) + (@window.text_input == @text_input ? '_' : '')
+    @text_font.draw(
+      text.ljust(43 - score.size, '.') + score,
+      X_OFFSET, 9 * Block::SIZE, 0, 1.0, 1.0, TEXT_FONT[2])
+
+    @hiscores.each_with_index do |record, i|
+      score  = record[1].to_s
+
+      @text_font.draw(
+        record[0].ljust(43 - score.size, '.') + score,
+        X_OFFSET, (10 + i) * Block::SIZE,
+        0, 1.0, 1.0, TEXT_FONT[2])
+    end
+  end
+
+  def score=(score)
+    @score    = score
+    @hiscores = Records.top(14)
+    @window.text_input = @text_input
+  end
+
+  def reset!
+    @score    = 0
+    @hiscores = []
+    @window.text_input = nil
+  end
+
+  def enter!
+    name = @text_input.text.strip
+    unless name == ''
+      Records.add(name, @score)
+      @window.text_input = nil
+    end
+  end
+end

data/lib/game.rb

@@ -0,0 +1,104 @@
+#
+# The main game window class
+#
+# NOTE: all the sizes in the code are _in_blocks_
+#
+# Copyright (C) 2011 Nikolay Nemshilov
+#
+class Game < Window
+
+  attr_accessor :glass, :status
+
+  def initialize
+    super(27 * Block::SIZE, 27 * Block::SIZE, false)
+    self.caption = "Pentix"
+
+    @glass    = Glass.new(self,   1, 1)
+    @status   = Status.new(self, 16, 1)
+
+    @controls = Controls.new     # keybindings
+    @finish   = Finish.new(self) # the gameover screen
+
+    reset!
+  end
+
+  def draw
+    if @playing
+      @glass.draw
+      @status.draw
+      @figure.draw
+    else
+      @finish.draw
+    end
+  end
+
+  def update
+    if @playing && time_to_move
+      if @figure.distance > 0
+        @figure.move_down
+      else
+        @figure.drop
+      end
+    end
+  end
+
+  def reset!
+    @status.reset!
+    @glass.reset!
+    @finish.reset!
+
+    show_next_figure
+
+    @time_offset = 1000 / @status.level # blocks per second
+    @next_time   = 0
+
+    time_to_move # precalculating the next time to move
+
+    @playing     = true
+  end
+
+  def its_over!
+    @finish.score = @status.score
+    @playing = false
+  end
+
+  def button_down(button)
+    case @controls.command_for(button)
+      when :drop       then @figure.drop        if @playing
+      when :left       then @figure.move_left   if @playing
+      when :right      then @figure.move_right  if @playing
+      when :turn_left  then @figure.turn_left   if @playing
+      when :turn_right then @figure.turn_right  if @playing
+      when :reset      then reset!
+      when :quit       then close
+      else
+        @finish.enter! if button == Button::KbReturn
+    end
+  end
+
+  def show_next_figure
+    @figure        = @status.figure || Figure.new(self)
+    @status.figure = Figure.new(self)
+
+    x = (Glass::WIDTH - @figure.size_x)/2 + 2
+    y = @glass.pos_y
+
+    if @glass.has_space_for?(@figure.matrix, x, y)
+      @figure.move_to(x, y)
+    else
+      @figure.pos_x = x
+      @figure.pos_y = y
+
+      its_over!
+    end
+  end
+
+  def time_to_move
+    if Gosu::milliseconds > @next_time
+      @next_time = Gosu::milliseconds + @time_offset
+    else
+      false
+    end
+  end
+
+end

data/lib/glass.rb

@@ -0,0 +1,158 @@
+#
+# The glass thing. It handles the figure position calculcations
+# watches the available space, removes full lines, etc, etc.
+#
+# Copyright (C) 2011 Nikolay Nemshilov
+#
+class Glass
+  attr_accessor :pos_x, :pos_y, :matrix
+
+  WIDTH  = 12
+  HEIGHT = 24
+  COLOR  = Color::GRAY
+
+  #
+  # Basic constructor
+  #
+  def initialize(window, x, y)
+    @window = window
+    @block  = Block.new(window, COLOR)
+
+    @pos_x  = x
+    @pos_y  = y
+
+    reset!
+  end
+
+  #
+  # Empties the glass by creating a new blocks matrix
+  #
+  def reset!
+    @matrix = (0..HEIGHT-1).map do
+      Array.new(WIDTH)
+    end
+  end
+
+  #
+  # Draws the class walls and content
+  #
+  def draw
+    @block.color = COLOR
+
+    # drawing the walls
+    (0..HEIGHT).each do |i|
+      @block.draw(@pos_x,  @pos_y + i)
+      @block.draw(@pos_x + WIDTH + 1, @pos_y + i)
+    end
+
+    # drawing the bottom
+    (1..WIDTH).each do |i|
+      @block.draw(@pos_x + i, @pos_y + HEIGHT)
+    end
+
+    # drawing the blocks inside
+    @matrix.each_with_index do |row, y|
+      row.each_with_index do |color, x|
+        unless color == nil
+          @block.color = color
+          @block.draw(@pos_x + x + 1, @pos_y + y)
+        end
+      end
+    end
+  end
+
+  #
+  # Calculates the available space (in blocks)
+  # below the figure
+  #
+  def spaces_below(figure)
+    fig_x = figure.pos_x - @pos_x - 1
+    fig_y = figure.pos_y - @pos_y
+
+    (0..figure.size_x-1).map do |x|
+      column_height = 0
+
+      figure.matrix.each_with_index do |row, y|
+        column_height = y + 1 if row[x]
+      end
+
+      lowest_point = fig_y + column_height
+
+      x += fig_x
+      distance = HEIGHT - lowest_point
+
+      # checking if it interescts with any existing blocks
+      @matrix.each_with_index do |row, y|
+        if nil != row[x]
+          distance = y - lowest_point
+          break
+        end
+      end
+
+      distance
+    end.min
+  end
+
+  #
+  # Checks if this figure matrix can fit the glass at the given
+  # position. Used for prechecks on figure manipulations to
+  # enforce movement constraints
+  #
+  def has_space_for?(matrix, pos_x, pos_y)
+    if pos_x > @pos_x && pos_x < (@pos_x + WIDTH + 2 - matrix[0].size)
+      if pos_y >= @pos_y && pos_y < (@pos_y + HEIGHT + 1 - matrix.size)
+        matrix.each_with_index do |row, y|
+          row.each_with_index do |visible, x|
+            if visible && nil != @matrix[pos_y - @pos_y + y][pos_x - @pos_x + x - 1]
+              return false
+            end
+          end
+        end
+
+        return true
+      end
+    end
+
+    false
+  end
+
+  #
+  # Glues the figure into the glass. The figure might hang above
+  # or virtually get through the stack, it doesn't matter. This
+  # method uses the horizontal position only
+  #
+  def glue_in(figure)
+    @window.status.count_drop(figure)
+
+    (0..figure.size_x - 1).each do |x|
+      (0..figure.size_y-1).each do |y|
+        if figure.matrix[y][x]
+          @matrix[
+            y + figure.pos_y - @pos_y + figure.distance
+          ][
+            x + figure.pos_x - @pos_x - 1
+          ] = figure.color
+        end
+      end
+    end
+
+    remove_full_lines
+  end
+
+  #
+  # Checks the glass for full lines, removes them
+  # and refills the glass
+  #
+  def remove_full_lines
+    lines = @matrix.map do |row|
+      row.all? ? row : nil
+    end.compact!
+
+    lines.each do |row|
+      @matrix.delete(row)
+      @matrix.unshift Array.new(WIDTH)
+    end
+
+    @window.status.count_kill(lines)
+  end
+end

data/lib/records.rb

@@ -0,0 +1,40 @@
+#
+# A little wrapper to handle hiscore records
+#
+class Records < Array
+  FILENAME = File.join(ENV['HOME'] || ENV['USERPROFILE'], ".pentix")
+
+  def self.new
+    @@instance ||= super # no need to bother HDD all the time
+  end
+
+  def self.top(size)
+    new.sort{ |a, b| b[1] <=> a[1] }.uniq.slice(0, size)
+  end
+
+  def self.add(name, score)
+    list = self.new
+    list << [name.strip, score]
+    list.save
+  end
+
+  def initialize(*args)
+    super *args
+
+    File.read(FILENAME).split("\n").each do |line|
+      if match = line.match(/^\s*(.*?)\s+(\d+)\s*$/)
+        self << [match[1].strip, match[2].to_i]
+      end
+    end if File.exists?(FILENAME)
+  end
+
+  def save
+    File.open(FILENAME, "w") do |file|
+      each do |entry|
+        if entry[1] > 0
+          file.write "#{entry[0].ljust(40, ' ')} #{entry[1]}\n"
+        end
+      end
+    end
+  end
+end