btetris_kp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 425a26d38d0419d50ff8cb0126faaa1caaf6d1e0
+  data.tar.gz: f8f2deaa630c4a9bd247656156d7869aa2725142
+SHA512:
+  metadata.gz: ae3785d6fd1403caefa5074b9e10fde7da908ad09338bcdce001e32de21c5e464aa8cd5062d977573c109afa4b386457345286bbd5a222dd1bf6da8b099c1f57
+  data.tar.gz: e0eb2eda6ba106b60420ce7ea59a58c0c89f9af787fe8212660c98fa87514bdd912f1f7590bfd3e7b1b4169d5ba92a389dbb3af94aaf9197077e6df20263142d

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*~
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in btetris_kp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Pavel Kocka
+
+MIT License
+
+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,29 @@
+# BtetrisKp
+
+Battle Tetris - tetris game for 2 player via lan
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'btetris_kp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install btetris_kp
+
+## Usage
+
+run btetris_kp
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/btetris_kp

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'btetris_kp/btetris'
+
+BTetrisKp::BTetrisWindow.new.show

data/btetris_kp.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'btetris_kp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "btetris_kp"
+  spec.version       = BtetrisKp::VERSION
+  spec.authors       = ["Pavel Kocka"]
+  spec.email         = ["kockapav@gmail.com"]
+  spec.description   = %q{Battle Tetris}
+  spec.summary       = %q{Tetris for 2 players via lan}
+  spec.homepage      = "https://github.com/kockapav/btetris_kp"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 0"
+  spec.add_development_dependency "gosu", "~> 0.7"
+  spec.add_development_dependency "rspec", "~> 2.14"
+end

data/lib/btetris_kp/btetris.rb

@@ -0,0 +1,37 @@
+require 'gosu'
+require 'btetris_kp/menu'
+require 'btetris_kp/constants'
+
+module BTetrisKp
+  # Main class maintaining game window,
+  # drawing, updating and reacting to key events
+  class BTetrisWindow < Gosu::Window
+    attr_accessor :state
+
+    def initialize
+      super(Const::GAME_WIDTH, Const::GAME_HEIGHT, false)
+      self.caption = Const::GAME_CAPTION
+      @state = MenuState.new(self)
+    end
+
+    # propagates update event to current window state
+    def update
+      @state.update
+    end
+
+    # propagates draw event to current window state
+    def draw
+      @state.draw
+    end
+
+    # propagates button_down event to current window state
+    def button_down(id)
+      @state.button_down(id)
+    end
+
+    # shows or hides default system cursor depending on state
+    def needs_cursor?
+      @state.needs_cursor?
+    end
+  end
+end

data/lib/btetris_kp/constants.rb

@@ -0,0 +1,197 @@
+module BTetrisKp
+  # module with constants, colors, tile shapes
+  module Const
+    # Game window Const
+    GAME_WIDTH = 800
+    GAME_HEIGHT = 600
+    GAME_CAPTION = 'Battle tetris'
+    PAUSE_CAPTION = 'Paused!'
+    GAME_OVER_CAPTION = 'Game over!'
+    GAME_WON_CAPTION = 'You WIN!'
+    GAME_LOST_CAPTION = 'You LOOSE!'
+
+    # File paths
+    PATH = File.dirname(File.expand_path(__FILE__))
+    PATH_IMAGE_TITLE = File.join(PATH, '../../media/title.png')
+    PATH_SND_DROP = File.join(PATH, '../../media/drop.ogg')
+    PATH_SND_POP = File.join(PATH, '../../media/pop.ogg')
+    PATH_SND_ROTATE = File.join(PATH, '../../media/rotate.ogg')
+
+    # Menu item captions
+    MENU_NEW = 'New game'
+    MENU_CREATE = 'Create net game'
+    MENU_JOIN = 'Join net game'
+    MENU_QUIT = 'Quit'
+
+    # Net captions
+    IP_CAPTION = 'IP:'
+    PORT_CAPTION = 'Port:'
+    CONNECTING = 'Connecting...'
+    DEF_IP = '127.0.0.1'
+    DEF_PORT = ''
+    SERVER_WAIT = 'Waiting for client to connect...'
+    SERVER_PORT = 'Used port: '
+
+    # Game Const
+    GAME_SPEED = 60
+    DROP_SPEED = 5
+    TURN_SPEED = 8
+    GAME_WON = 1
+    GAME_LOST = -1
+    GAME_ON = 0
+
+    # Size of board in pieces
+    PNR_HOR = 10
+    PNR_VER = 20
+
+    # TextInput Const
+    BORDER_GAP = 5
+
+    # Network Const
+    GOT_NO_MESSAGE = '0'
+    MSG_PAUSE = '1'
+    MSG_GAME_OVER = '2'
+    MSG_BOARD = '3'
+    MSG_GARBAGE = '4'
+    MSG_WELCOME = '5'
+
+    # Color Const
+    BOARD_BACK_CLR = Gosu::Color.new(0xFF101010)
+    BOARD_CLR = Gosu::Color.new(0xFFB8B8B8)
+    CARET_CLR = Gosu::Color.new(0xFFFFFFFF)
+    MENU_ITEM_CLR = Gosu::Color.new(0xFFFFFFFF)
+    MENU_ITEM_MO_CLR = Gosu::Color.new(0xFFCCFF33)
+    # NR of colors shouldnt be higher then 9, (board#from_s)
+    TILE_COLORS_NR = 8
+    TILE_COLORS = [0,
+                   Gosu::Color.new(0xFFC80000),
+                   Gosu::Color.new(0xFF0000CC),
+                   Gosu::Color.new(0xFF990066),
+                   Gosu::Color.new(0xFF99FF00),
+                   Gosu::Color.new(0xFFCCFF00),
+                   Gosu::Color.new(0xFFFF6600),
+                   Gosu::Color.new(0xFF00FF99),
+                   Gosu::Color.new(0xFFFFFF00)]
+    TILE_BRIGHT_CLR = [0,
+                       Gosu::Color.new(0xFFE00000),
+                       Gosu::Color.new(0xFF0033CC),
+                       Gosu::Color.new(0xFF990099),
+                       Gosu::Color.new(0xFF99FF33),
+                       Gosu::Color.new(0xFFCCFF33),
+                       Gosu::Color.new(0xFFFF6633),
+                       Gosu::Color.new(0xFF00FFCC),
+                       Gosu::Color.new(0xFFFFFF33)]
+    TILE_SHADOW_CLR = [0,
+                       Gosu::Color.new(0xFF700000),
+                       Gosu::Color.new(0xFF000099),
+                       Gosu::Color.new(0xFF990033),
+                       Gosu::Color.new(0xFF99CC00),
+                       Gosu::Color.new(0xFFCCCC00),
+                       Gosu::Color.new(0xFFFF3300),
+                       Gosu::Color.new(0xFF00CC99),
+                       Gosu::Color.new(0xFFFFCC00)]
+
+    TILES =
+    [
+      [
+        [
+          [1, 1],
+          [1, 1]
+        ]
+      ],
+      [
+        [
+          [1, 1, 1],
+          [0, 1, 0]
+        ],
+        [
+          [0, 1],
+          [1, 1],
+          [0, 1]
+        ],
+        [
+          [0, 1, 0],
+          [1, 1, 1]
+        ],
+        [
+          [1, 0],
+          [1, 1],
+          [1, 0]
+        ]
+      ],
+      [
+        [
+          [1, 1, 0],
+          [0, 1, 1]
+        ],
+        [
+          [0, 1],
+          [1, 1],
+          [1, 0]
+        ]
+      ],
+      [
+        [
+          [0, 1, 1],
+          [1, 1, 0]
+        ],
+        [
+          [1, 0],
+          [1, 1],
+          [0, 1]
+        ]
+      ],
+      [
+        [
+          [1, 1, 1, 1]
+        ],
+        [
+          [1],
+          [1],
+          [1],
+          [1]
+        ]
+      ],
+      [
+        [
+          [1, 0, 0],
+          [1, 1, 1]
+        ],
+        [
+          [1, 1],
+          [1, 0],
+          [1, 0]
+        ],
+        [
+          [1, 1, 1],
+          [0, 0, 1]
+        ],
+        [
+          [0, 1],
+          [0, 1],
+          [1, 1]
+        ]
+      ],
+      [
+        [
+          [0, 0, 1],
+          [1, 1, 1]
+        ],
+        [
+          [1, 0],
+          [1, 0],
+          [1, 1]
+        ],
+        [
+          [1, 1, 1],
+          [1, 0, 0]
+        ],
+        [
+          [1, 1],
+          [0, 1],
+          [0, 1]
+        ]
+      ]
+    ]
+  end
+end

data/lib/btetris_kp/core/board.rb

@@ -0,0 +1,223 @@
+require 'btetris_kp/menu'
+require 'btetris_kp/core/piece'
+
+module BTetrisKp
+  # class representing one tetris board
+  class Board
+    attr_accessor :board, :cur_piece
+
+    def initialize(window, posx, posy)
+      @window = window
+      @tile_size = @window.width / 30
+
+      # board corners position
+      @posx = posx
+      @posx2 = posx + Const::PNR_HOR * @tile_size
+      @posy = posy
+      @posy2 = posy + Const::PNR_VER * @tile_size
+
+      # initializes board array and current piece
+      @board = Array.new(Const::PNR_VER) { Array.new(Const::PNR_HOR, 0) }
+      @cur_piece = Piece.new(@board, 0, Const::PNR_HOR / 3 + 1, rand(Const::TILES.size))
+    end
+
+    # generates new piece,
+    # current piece is set on board and replaced by new one
+    def new_piece!
+      @cur_piece.set_on_board
+      @cur_piece = Piece.new(@board, 0, Const::PNR_HOR / 3 + 1, rand(Const::TILES.size))
+    end
+
+    # checks whether piece can move down
+    def piece_stuck?
+      @cur_piece.move_down!
+      can_be_set = @cur_piece.can_be_set?
+      @cur_piece.move_up!
+      !can_be_set
+    end
+
+    # moves piece left
+    def piece_left!
+      @cur_piece.move_left!
+      @cur_piece.move_right! unless @cur_piece.can_be_set?
+    end
+
+    # moves piece right
+    def piece_right!
+      @cur_piece.move_right!
+      @cur_piece.move_left! unless @cur_piece.can_be_set?
+    end
+
+    # moves piece down faster
+    def piece_down!
+      @cur_piece.move_down!
+      @cur_piece.move_up! unless @cur_piece.can_be_set?
+    end
+
+    # rotates piece, returns true when successful
+    def piece_rotate!
+      @cur_piece.rotate_right!
+      return true if @cur_piece.can_be_set?
+      @cur_piece.rotate_left!
+      false
+    end
+
+    # drops peace down as far as possible
+    def piece_drop!
+      @cur_piece.move_down! while @cur_piece.can_be_set?
+      @cur_piece.move_up!
+    end
+
+    # next step of game, returns count of cleared rows
+    def next_step!
+      cnt = 0
+      @cur_piece.move_down!
+      unless @cur_piece.can_be_set?
+        @cur_piece.move_up!
+        new_piece!
+        cnt = clear_rows!
+      end
+      cnt
+    end
+
+    # copies content of one row into another
+    # r1 - source row, r2 - destination row
+    def copy_row(r1, r2)
+      if r1 < 0
+        @board[r2].each_with_index { |val, index| @board[r2][index] = 0 }
+      else
+        @board[r1].each_with_index { |val, index| @board[r2][index] = val }
+      end
+    end
+
+    # fills row randomly with blocks and spaces
+    # atleast one block has to be empty space
+    def fill_row_randomly(index)
+      @board[index].each_with_index do |val, x|
+        @board[index][x] = rand(Const::TILE_COLORS_NR + 1)
+      end
+      @board[index][rand(Const::PNR_HOR)] = 0
+    end
+
+    # inserts garbage in board depending on count of cleared rows
+    def insert_garbage!(cnt)
+      for index in cnt.upto(Const::PNR_VER - 1)
+        copy_row(index, index - cnt)
+      end
+      for index in (Const::PNR_VER - cnt).upto(Const::PNR_VER - 1)
+        fill_row_randomly(index)
+      end
+    end
+
+    # moves down all rows with smaller index then row_index,
+    # removing row at row_index content in the process
+    def clear_row!(row_index)
+      for index in row_index.downto(0) do
+        copy_row(index - 1, index)
+      end
+    end
+
+    # clears rows that are full, returns number of cleared rows
+    def clear_rows!
+      cnt = 0
+      @board.each_with_index do |row, index|
+        unless row.include?(0)
+          clear_row!(index)
+          cnt += 1
+        end
+      end
+      cnt
+    end
+
+    # checks if game is over
+    def game_over?
+      !@cur_piece.can_be_set?
+    end
+
+    # draws board border and background
+    def draw_background
+      @window.draw_quad(@posx, @posy, Const::BOARD_BACK_CLR,
+                        @posx2, @posy, Const::BOARD_BACK_CLR,
+                        @posx,  @posy2, Const::BOARD_BACK_CLR,
+                        @posx2, @posy2, Const::BOARD_BACK_CLR)
+      @window.draw_line(@posx - 1, @posy - 1, Const::BOARD_CLR,
+                        @posx2 + 1, @posy - 1, Const::BOARD_CLR)
+      @window.draw_line(@posx2 + 1, @posy - 1, Const::BOARD_CLR,
+                        @posx2 + 1, @posy2 + 1, Const::BOARD_CLR)
+      @window.draw_line(@posx - 1, @posy - 1, Const::BOARD_CLR,
+                        @posx - 1, @posy2 + 1, Const::BOARD_CLR)
+      @window.draw_line(@posx - 1, @posy2 + 1, Const::BOARD_CLR,
+                        @posx2 + 1, @posy2 + 1, Const::BOARD_CLR)
+    end
+
+    # draws block on board
+    def draw_block(x, y, val)
+      unless val == 0
+        x1 = @posx + x * @tile_size
+        x2 = @posx + (x + 1) * @tile_size
+        y1 = @posy + y * @tile_size
+        y2 = @posy + (y + 1) * @tile_size
+
+        @window.draw_quad(x1, y1, Const::TILE_COLORS[val],
+                          x2, y1, Const::TILE_COLORS[val],
+                          x1, y2, Const::TILE_COLORS[val],
+                          x2, y2, Const::TILE_COLORS[val])
+
+        @window.draw_line(x2 - 1, y1 + 1, Const::TILE_SHADOW_CLR[val],
+                          x2 - 1, y2 - 1, Const::TILE_SHADOW_CLR[val])
+        @window.draw_line(x1 + 1 , y2 - 1, Const::TILE_SHADOW_CLR[val],
+                          x2 - 1, y2 - 1, Const::TILE_SHADOW_CLR[val])
+        @window.draw_line(x2, y1, Const::TILE_SHADOW_CLR[val],
+                          x2, y2, Const::TILE_SHADOW_CLR[val])
+        @window.draw_line(x1, y2, Const::TILE_SHADOW_CLR[val],
+                          x2, y2, Const::TILE_SHADOW_CLR[val])
+
+        @window.draw_line(x1, y1, Const::TILE_BRIGHT_CLR[val],
+                          x2, y1, Const::TILE_BRIGHT_CLR[val])
+        @window.draw_line(x1, y1, Const::TILE_BRIGHT_CLR[val],
+                          x1, y2, Const::TILE_BRIGHT_CLR[val])
+        @window.draw_line(x1 + 1, y1 + 1, Const::TILE_BRIGHT_CLR[val],
+                          x2 - 1, y1 + 1, Const::TILE_BRIGHT_CLR[val])
+        @window.draw_line(x1 + 1, y1 + 1, Const::TILE_BRIGHT_CLR[val],
+                          x1 + 1, y2 - 1, Const::TILE_BRIGHT_CLR[val])
+      end
+    end
+
+    # draws board and all blocks on it
+    def draw
+      draw_background
+      @cur_piece.set_on_board
+      @board.each_with_index do |row, y|
+        row.each_with_index do |val, x|
+          draw_block(x, y, val)
+        end
+      end
+      @cur_piece.unset_on_board
+    end
+
+    # loads board content from string
+    # !!! (expects board to contain only nrs from 0 to 9) !!!
+    def from_s!(state)
+      @board = state.split('').map { |i| i.to_i }.each_slice(Const::PNR_HOR).to_a
+    end
+
+    # returns string of board with current piece
+    def get_board_s
+      @cur_piece.set_on_board
+      s = to_s
+      @cur_piece.unset_on_board
+      s
+    end
+
+    # converts board content to string
+    def to_s
+      s = ''
+      @board.each do |row|
+        row.each do |val|
+          s << val.to_s
+        end
+      end
+      s
+    end
+  end
+end

data/lib/btetris_kp/core/piece.rb

@@ -0,0 +1,79 @@
+require 'btetris_kp/constants'
+
+module BTetrisKp
+  # class representing actual piece in game
+  class Piece
+    def initialize(board, posx, posy, piece_nr)
+      @board = board
+      @posx = posx
+      @posy = posy
+      @nr = piece_nr
+      @rot = 0
+      @color = rand(Const::TILE_COLORS_NR) + 1
+      @piece = Const::TILES[@nr][@rot]
+    end
+
+    # moves piece one block to the left
+    def move_left!
+      @posy -= 1
+    end
+
+    # moves piece one block to the right
+    def move_right!
+      @posy += 1
+    end
+
+    # moves piece one block up
+    def move_up!
+      @posx -= 1
+    end
+
+    # moves piece one block down
+    def move_down!
+      @posx += 1
+    end
+
+    # rotates piece left
+    def rotate_left!
+      @rot = (@rot - 1) % Const::TILES[@nr].size
+      @piece = Const::TILES[@nr][@rot]
+    end
+
+    # rotates piece right
+    def rotate_right!
+      @rot = (@rot + 1) % Const::TILES[@nr].size
+      @piece = Const::TILES[@nr][@rot]
+    end
+
+    # returns true if there is no collision with peace on board
+    def can_be_set?
+      return false if @posx < 0 || @posy < 0
+      @piece.each_with_index do |row, x|
+        row.each_with_index do |val, y|
+          return false if @posx + x > Const::PNR_VER - 1 ||
+                          @posy + y > Const::PNR_HOR - 1
+          return false if @board[@posx + x][@posy + y] > 0 && val > 0
+        end
+      end
+      true
+    end
+
+    # sets peace on board
+    def set_on_board
+      @piece.each_with_index do |row, x|
+        row.each_with_index do |val, y|
+          @board[@posx + x][@posy + y] = @color if val == 1
+        end
+      end
+    end
+
+    # unsets peace from board
+    def unset_on_board
+      @piece.each_with_index do |row, x|
+        row.each_with_index do |val, y|
+          @board[@posx + x][@posy + y] = 0 if val == 1
+        end
+      end
+    end
+  end
+end