Tetris 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7ce32b8877ef2c2a93a80eda998759003fb2c117
+  data.tar.gz: cddfe6415bbd8217f23d7442f35c4e76b76fc51f
+SHA512:
+  metadata.gz: 398beb852d5c477e900c663d9dc598598baf2afab355f40e3769bce2a541042496c46879cb2f65899bfb661da4ec6245d3d827b7369d48008739eabee3b46383
+  data.tar.gz: 771a5cca7efea5491c3a7dcc1d74a4972d44ad4a049b14d5c0e08ffad3fbf6fb31f5d04f4e35c6695d99327871c5c5bea36595366cfff27382fc2361108a8db0

data/bin/tetris

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'tetris'
+game = Game.new
+game.show

data/lib/block.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'gosu'
+
+# One block - each shape is formed by multiple blocks
+class Block
+  attr_accessor :x, :y, :color
+
+  @@image = nil
+  @@width = 32
+  @@height = 32
+
+  def self.width
+    @@width
+  end
+
+  def self.height
+    @@height
+  end
+
+  def initialize(game, x = 0, y = 0)
+    @@image = Gosu::Image.new(game, '../media/block.png', false) if @@image.nil?
+    @@width = @@image.width unless @@image.nil?
+    @@height = @@image.height unless @@image.nil?
+
+    @x = x
+    @y = y
+    @game = game
+
+    # AA RR GG BB
+    @color = 0xFFFF0000
+  end
+
+  def draw
+    # x, y, z, factor_z, factor_y, color, mode (= :default)
+    @@image.draw(@x, @y, 0, 1, 1, @color)
+  end
+
+  def collides_with_blocks?
+    @game.blocks.each do |block|
+      return true if block.x == @x && block.y == @y
+    end
+
+    false
+  end
+end

data/lib/shape.rb

@@ -0,0 +1,154 @@
+require 'gosu'
+
+# General Shape class
+class Shape
+  attr_accessor :rotation, :x, :y
+  attr_reader :blocks
+
+  def initialize(game)
+    @game = game
+    @x = @y = 0
+    @blocks = []
+
+    # is the shape currently falling?
+    @falling = true
+
+    # by which block to rotate
+    @rotation_block = @blocks[1]
+
+    # how many rotation states are there
+    @rotations = 1
+
+    # rotation state
+    @rotation = 0
+  end
+
+  def update
+    return unless @falling
+
+    old_x = @x
+    old_y = @y
+
+    # first handle x change (handle keyboard - movement -
+    # and check for collision)
+    if update_move_x
+      if @game.button_down?(Gosu::KbLeft)
+        @x -= 32
+      elsif @game.button_down?(Gosu::KbRight)
+        @x += 32
+      end
+
+      @x = old_x if collides?
+    end
+
+    # then handle y change, so we can set @falling to false
+    # game speed check
+
+    if update_move_y
+      @y += 32
+
+      if collides?
+        @y = old_y
+        @falling = false
+      end
+    end
+  end
+
+  # Rotates the shape
+  def rotate
+    return if @rotation_block.nil?
+
+    (1..@rotation % @rotations).each do |_i|
+      @blocks.each do |block|
+        old_x = block.x
+        old_y = block.y
+        block.x = @rotation_block.x + (@rotation_block.y - old_y)
+        block.y = @rotation_block.y - (@rotation_block.x - old_x)
+      end
+    end
+  end
+
+  def shape_to_array
+    blocks_array = []
+    get_blocks.each do |block|
+      blocks_array << [block.x, block.y]
+    end
+    blocks_array
+  end
+
+  # updates move counter
+  def update_move_x
+    if @game.elapsed_seconds > @game.last_move_x + 0.05
+      @game.last_move_x = @game.elapsed_seconds
+    end
+  end
+
+  def update_move_y
+    if @game.button_down?(Gosu::KbDown)
+      @game.game_speed *= 0.2
+    else
+      @game.game_speed = 1
+    end
+
+    if @game.elapsed_seconds > @game.last_move_y + @game.game_speed
+      @game.last_move_y = @game.elapsed_seconds
+    end
+  end
+
+  def collides?
+    if collides_with_walls? || collides_with_blocks?
+      return true
+    end
+
+    false
+  end
+
+  def collides_with_walls?
+    max_y = maximum_y_block
+    min_x = minimum_x_block
+    max_x = maximum_x_block
+
+    min_x.x < 0 || max_x.x >= @game.screen_width || max_y.y + Block.height > @game.screen_height
+  end
+
+  def collides_with_blocks?
+    get_blocks.each do |block|
+      return true if block.collides_with_blocks?
+    end
+
+    false
+  end
+
+  # note that maximum y means the lowest block!
+  def maximum_y_block
+    get_blocks.max_by(&:y)
+  end
+
+  def minimum_x_block
+    get_blocks.min_by(&:x)
+  end
+
+  def maximum_x_block
+    get_blocks.max_by(&:x)
+  end
+
+  # flips the shape by y axis
+  def translate_by_y
+    min = @blocks.min_by(&:x)
+    max = @blocks.max_by(&:x)
+    center = (min.x + max.x) / 2.0
+    @blocks.each do |block|
+      block.x = 2 * center - block.x - Block.width
+    end
+  end
+
+  def draw
+    get_blocks.each(&:draw)
+  end
+
+  def falling?
+    @falling
+  end
+
+  attr_writer :falling
+end

data/lib/shapeI.rb

@@ -0,0 +1,38 @@
+require 'shape.rb'
+require 'block.rb'
+
+# [ ]
+# [ ]
+# [ ]
+# [ ]
+class ShapeI < Shape
+  def initialize(game)
+    super(game)
+
+    @blocks[0] = Block.new(game)
+    @blocks[1] = Block.new(game)
+    @blocks[2] = Block.new(game)
+    @blocks[3] = Block.new(game)
+
+    @rotation_block = @blocks[1]
+    @rotations = 2
+
+    @blocks.each do |block|
+      block.color = 0xFFFF0000
+    end
+  end
+
+  def get_blocks
+    @blocks[0].x = @x
+    @blocks[1].x = @x
+    @blocks[2].x = @x
+    @blocks[3].x = @x
+
+    @blocks[0].y = @y
+    @blocks[1].y = @blocks[0].y + Block.height
+    @blocks[2].y = @blocks[1].y + Block.height
+    @blocks[3].y = @blocks[2].y + Block.height
+    rotate
+    @blocks
+  end
+end

data/lib/shapeJ.rb

@@ -0,0 +1,20 @@
+require 'shapeL.rb'
+require 'block.rb'
+
+#    [ ]
+#    [ ]
+# [ ][ ]
+class ShapeJ < ShapeL
+  def get_blocks
+    old_rotation = @rotation
+    @rotation = 0
+
+    super
+    translate_by_y
+
+    @rotation = old_rotation
+    rotate
+
+    @blocks
+  end
+end

data/lib/shapeL.rb

@@ -0,0 +1,37 @@
+require 'shape.rb'
+require 'block.rb'
+
+# [ ]
+# [ ]
+# [ ][ ]
+class ShapeL < Shape
+  def initialize(game)
+    super(game)
+
+    @blocks[0] = Block.new(game)
+    @blocks[1] = Block.new(game)
+    @blocks[2] = Block.new(game)
+    @blocks[3] = Block.new(game)
+
+    @rotation_block = @blocks[1]
+    @rotations = 4
+
+    @blocks.each do |block|
+      block.color = 0xFF0000FF
+    end
+  end
+
+  def get_blocks
+    @blocks[0].x = @x
+    @blocks[1].x = @x
+    @blocks[2].x = @x
+    @blocks[3].x = @x + Block.width
+
+    @blocks[0].y = @y
+    @blocks[1].y = @blocks[0].y + Block.height
+    @blocks[2].y = @blocks[1].y + Block.height
+    @blocks[3].y = @blocks[2].y
+    rotate
+    @blocks
+  end
+end

data/lib/shapeO.rb

@@ -0,0 +1,35 @@
+require 'shape.rb'
+require 'block.rb'
+
+# [ ][ ]
+# [ ][ ]
+class ShapeO < Shape
+  def initialize(game)
+    super(game)
+
+    @blocks[0] = Block.new(game)
+    @blocks[1] = Block.new(game)
+    @blocks[2] = Block.new(game)
+    @blocks[3] = Block.new(game)
+
+    @rotations = 1
+
+    @blocks.each do |block|
+      block.color = 0xFF00FF00
+    end
+  end
+
+  def get_blocks
+    @blocks[0].x = @x
+    @blocks[1].x = @x + Block.width
+    @blocks[2].x = @x
+    @blocks[3].x = @x + Block.width
+
+    @blocks[0].y = @y
+    @blocks[1].y = @y
+    @blocks[2].y = @blocks[0].y + Block.height
+    @blocks[3].y = @blocks[1].y + Block.height
+
+    @blocks
+  end
+end

data/lib/shapeS.rb

@@ -0,0 +1,37 @@
+require 'shape.rb'
+require 'block.rb'
+
+# [ ]
+# [ ][ ]
+#    [ ]
+class ShapeS < Shape
+  def initialize(game)
+    super(game)
+
+    @blocks[0] = Block.new(game)
+    @blocks[1] = Block.new(game)
+    @blocks[2] = Block.new(game)
+    @blocks[3] = Block.new(game)
+
+    @rotation_block = @blocks[1]
+    @rotations = 2
+
+    @blocks.each do |block|
+      block.color = 0xFFFFFF00
+    end
+  end
+
+  def get_blocks
+    @blocks[0].x = @x
+    @blocks[1].x = @x
+    @blocks[2].x = @x + Block.width
+    @blocks[3].x = @x + Block.width
+
+    @blocks[0].y = @y
+    @blocks[1].y = @blocks[0].y + Block.height
+    @blocks[2].y = @blocks[0].y + Block.height
+    @blocks[3].y = @blocks[2].y + Block.height
+    rotate
+    @blocks
+  end
+end

data/lib/shapeT.rb

@@ -0,0 +1,37 @@
+require 'shape.rb'
+require 'block.rb'
+
+# [ ][ ][ ]
+#    [ ]
+#    [ ]
+class ShapeT < Shape
+  def initialize(game)
+    super(game)
+
+    @blocks[0] = Block.new(game)
+    @blocks[1] = Block.new(game)
+    @blocks[2] = Block.new(game)
+    @blocks[3] = Block.new(game)
+
+    @rotation_block = @blocks[1]
+    @rotations = 4
+
+    @blocks.each do |block|
+      block.color = 0xFF00FFFF
+    end
+  end
+
+  def get_blocks
+    @blocks[0].x = @x
+    @blocks[1].x = @x + Block.width
+    @blocks[2].x = @blocks[1].x + Block.width
+    @blocks[3].x = @x + Block.width
+
+    @blocks[0].y = @y
+    @blocks[1].y = @y
+    @blocks[2].y = @y
+    @blocks[3].y = @y + Block.height
+    rotate
+    @blocks
+  end
+end

data/lib/shapeZ.rb

@@ -0,0 +1,14 @@
+require 'shapeS.rb'
+require 'block.rb'
+
+#    [ ]
+# [ ][ ]
+# [ ]
+class ShapeZ < ShapeS
+  def get_blocks
+    super
+    translate_by_y
+
+    @blocks
+  end
+end

data/lib/tetris.rb

@@ -0,0 +1,162 @@
+require 'rubygems'
+require 'gosu'
+require 'block.rb'
+require 'shapeL.rb'
+require 'shapeJ.rb'
+require 'shapeI.rb'
+require 'shapeO.rb'
+require 'shapeT.rb'
+require 'shapeZ.rb'
+require 'shapeS.rb'
+
+# Main class for Tetris.
+class Game < Gosu::Window
+  attr_accessor :blocks, :current_shape, :score, :fall_speed, :game_state
+  attr_accessor :game_speed, :screen_width, :screen_height, :elapsed_seconds
+  attr_accessor :last_move_x, :last_move_y
+
+  attr_reader :shape
+
+  STATE_PLAYING = 1
+  STATE_END = 2
+
+  def initialize
+    @screen_width = 320
+    @screen_height = 640
+
+    super(@screen_width, @screen_height, false)
+    @score = 0
+    @blocks = []
+    @game_state = STATE_END
+    @game_speed = 1 # the lower, the faster
+
+    @game_over_text = Gosu::Image.from_text(self, 'Game Over', 'Arial', 40)
+    @press_space_text = Gosu::Image.from_text(self, 'Press SPACE to start a new game', 'Arial', 15)
+    @music = Gosu::Song.new('../media/Tetris.ogg')
+
+    self.caption = "Tetris! (#{@score} Points)"
+    @shape = nil
+    @elapsed_seconds = 0
+    @last_move_y = 0
+    @last_move_x = 0
+  end
+
+  def draw
+    @blocks.each(&:draw)
+    @shape.draw unless @shape.nil?
+    return if @game_state != STATE_END
+
+    @game_over_text.draw(@screen_width / 2 - 75, @screen_height / 2 - 40, 0)
+    @press_space_text.draw(@screen_width / 2 - 85, @screen_height / 2, 0)
+  end
+
+  # this is a callback for key up events or equivalent (there are
+  # constants for gamepad buttons and mouse clicks)
+  def button_up(key)
+    close if key == Gosu::KbEscape
+  end
+
+  # better responsiveness than button_up (rotates the shape immediately)
+  def button_down(key)
+    if @game_state == STATE_END
+
+      # (re)start the game
+      if key == Gosu::KbSpace
+        @blocks = []
+        @score = 0
+        @shape = nil
+        self.caption = "Tetris! (#{@score} Points)"
+        @game_state = STATE_PLAYING
+        @music.stop
+
+        # true indicates whether it should loop
+        @music.play(true)
+      end
+    elsif @game_state == STATE_PLAYING
+      if key == Gosu::KbSpace && !@shape.nil?
+        @shape.rotation += 1
+        @shape.rotation -= 1 if @shape.collides?
+      end
+    end
+  end
+
+  # deletes complete lines
+  # returns the number of deleted lines
+  def delete_lines
+    lines_to_delete = []
+
+    @shape.get_blocks.each do |block|
+      sum = @blocks.count { |x| x.y == block.y }
+      if sum == @screen_width / Block.width
+        lines_to_delete << block.y
+        @blocks.delete_if { |x| x.y == block.y }
+      end
+    end
+
+    update_score(lines_to_delete)
+    move_blocks_down(lines_to_delete)
+
+    lines_to_delete
+  end
+
+  # updates score
+  def update_score(lines)
+    return if lines.empty?
+
+    @score += 2**(lines.size - 1)
+    self.caption = "Tetris! (#{@score} Points)"
+  end
+
+  # moves appropriate blocks down (typically after lines removal)
+  def move_blocks_down(lines)
+    return if lines.empty?
+
+    @blocks.each do |block|
+      block.y += lines.size * Block.height if block.y < lines.min
+    end
+  end
+
+  def update
+    update_delta
+
+    return if @game_state != STATE_PLAYING
+
+    # do we have a falling shape?
+    if !@shape.nil? && @shape.falling?
+      @shape.update
+    else
+      spawn_shape
+      @game_state = STATE_END if @shape.collides?
+    end
+    # with a delta we need to express the speed of our entities in
+    # terms of pixels/second
+  end
+
+  def update_delta
+    # Gosu::millisecodns returns the time since the window was created
+    # Divide by 1000 since we want to work in seconds
+    @current_time = Gosu.milliseconds / 1000.0
+    # clamping here is important to avoid strange behaviors
+    @delta = [@current_time - @elapsed_seconds, 0.25].min
+    @elapsed_seconds = @current_time
+  end
+
+  # Spawns a new shape
+  def spawn_shape
+    # Add the previous shape to the block list
+    unless @shape.nil?
+      @shape.get_blocks.each do |block|
+        @blocks << block
+      end
+
+      # erase completed lines
+      delete_lines
+    end
+
+    shapes = [ShapeJ.new(self), ShapeL.new(self), ShapeI.new(self), ShapeO.new(self), ShapeT.new(self), ShapeZ.new(self), ShapeS.new(self)]
+    @shape = shapes.sample
+
+    @shape.x = Block.width * 4
+    @shape.get_blocks
+  end
+end

data/test/spec_helper.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+RSpec.configure do |c|
+  c.color = true
+  c.formatter = :documentation
+  c.tty = true
+end

data/test/test_tetris.rb

@@ -0,0 +1,60 @@
+require_relative 'spec_helper'
+require_relative '../lib/tetris'
+require 'gosu'
+
+describe Game do
+  before(:each) do
+    @game = Game.new
+    @game.button_down(Gosu::KbSpace) # start the game
+    @game.update
+  end
+
+  context 'Initial score is 0' do
+    it { expect(@game.score).to eq 0 }
+  end
+
+  context 'There are no blocks at the beginning' do
+    it { expect(@game.blocks).to be_empty }
+  end
+
+  context 'A shape has spawned after the game has been started' do
+    it 'spawns a shape' do
+      expect(@game.shape).to_not be_nil
+    end
+  end
+
+  context 'No lines should be deleted at the beginning of the game' do
+    it 'Doesn\'t delete any lines' do
+      expect(@game.delete_lines.size).to eq 0
+    end
+  end
+
+  context 'The game should delete complete lines' do
+    before(:each) do
+      @game.shape.y = @game.screen_height
+
+      (0..(@game.screen_width - Block.width)).step(Block.width) do |i|
+        @game.blocks << Block.new(@game, i, @game.screen_height)
+      end
+    end
+
+    it 'Correctly deletes lines' do
+      expect(@game.delete_lines.size).to eq 1
+    end
+
+    it 'Correctly increases score' do
+      expect{@game.delete_lines}.to change{@game.score}.from(0).to(1)
+    end
+  end
+
+  context 'Player should be able to lose' do
+    it 'Player loses' do
+      (0..(@game.screen_width - Block.width)).step(Block.width) do |i|
+        @game.blocks << Block.new(@game, Block.width * 4, i)
+      end
+
+      @game.shape.falling = false
+      expect{@game.update}.to change{@game.game_state}.from(1).to(2)
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: Tetris
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Filip Vondrasek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-10 00:00:00.000000000 Z
+dependencies: []
+description: A simple Tetris game
+email: filip@vondrasek.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/tetris
+- lib/block.rb
+- lib/shape.rb
+- lib/shapeI.rb
+- lib/shapeJ.rb
+- lib/shapeL.rb
+- lib/shapeO.rb
+- lib/shapeS.rb
+- lib/shapeT.rb
+- lib/shapeZ.rb
+- lib/tetris.rb
+- media/Tetris.ogg
+- media/block.png
+- test/spec_helper.rb
+- test/test_tetris.rb
+homepage: ''
+licenses:
+- WTFPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A simple Tetris game
+test_files: []