yeah 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0c6e5215bc7f40ed78d1fba8db16ff7b0adf9d3
-  data.tar.gz: ddc2c5ebf36519ba42d7ddffd788dc4d20092534
+  metadata.gz: d01dc8962df50d909356224581bb6c5e566991f5
+  data.tar.gz: 789fa6d989ad7422f05e1b13fd1c2bea2718c128
 SHA512:
-  metadata.gz: 00dcbd4572d660d377624cc12b49412ef26b56844734c3bd43fe93fb24049179531fd956ed63aef47e584b48accbe465239cf5747663ab98db2a9d2773ab206e
-  data.tar.gz: 50f5ad56743ee6291682f66302cdddb75931502f2a205926dce1041b3012ee6df461453d5f9bbcd00c8d22f71e04f996b4202bf0cf7a12ee0cf83804ee44f30c
+  metadata.gz: a0ae07e88b7f9334db886be3caf5497d95528bdeaa69eb82ed24a56885f04426088e1878758732afd0ca33d4d327a640fe30fa38ed156f7ff425591717600ef9
+  data.tar.gz: 82e2bdb785e40f172378eeafc06e6c091ec0769fd06e7e8cd64a1806270526e3d18f811e50720efadd816617f73875d6d9f8d62f1702ceea84c4131dd626959b

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## 0.1.0 [2013-09-05]
+* Added basic Vector, Entity and Game classes.
+
+## 0.2.0 [2013-09-21]
+* Added Color, Surface, Rectangle, Map and Desktop classes.
+* Extended Vector, Entity and Game classes.
+* Added Happy Rectangle demo.

data/Gemfile

@@ -3,3 +3,4 @@ source 'https://rubygems.org'
 gem 'rspec'
 gem 'guard-rspec'
 gem 'libnotify'
+gem 'rubygame'

data/Gemfile.lock

@@ -22,10 +22,13 @@ GEM
       rb-kqueue (>= 0.2)
     lumberjack (1.0.4)
     method_source (0.8.1)
+    nice-ffi (0.4)
+      ffi (>= 0.5.0)
     pry (0.9.12.2)
       coderay (~> 1.0.5)
       method_source (~> 0.8)
       slop (~> 3.4)
+    rake (10.1.0)
     rb-fsevent (0.9.3)
     rb-inotify (0.9.0)
       ffi (>= 0.5.0)
@@ -39,6 +42,11 @@ GEM
     rspec-expectations (2.14.2)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.14.3)
+    ruby-sdl-ffi (0.4)
+      nice-ffi (>= 0.2)
+    rubygame (2.6.4)
+      rake (>= 0.7.0)
+      ruby-sdl-ffi (>= 0.1.0)
     slop (3.4.5)
     thor (0.18.1)
 
@@ -49,3 +57,4 @@ DEPENDENCIES
   guard-rspec
   libnotify
   rspec
+  rubygame

data/README.md

@@ -1,99 +1,12 @@
 Yeah
 ====
-The positive video game framework
+A Ruby video game framework that prioritizes happiness and agility over raw performance.
 
-Ruby is a good fit for game development for the following reasons:
-* Ruby is optimized for developer happiness, and this framework is, too. A happy developer is a productive developer, which translates into more games made and with greater passion.
-* Ruby has great object-oriented syntax that makes a lot of sense for game constructs.
-* Ruby's expressiveness reduces development time and makes it easier to experiment.
-* Ruby supports operator overloading, which is very handy for the linear algebra that is typically abundant in game code.
-* Code testing is wonderful and ubiquitous in the Ruby community, but the game development community has not embraced it. I hope this framework will help change that.
-* [Rubygame](https://github.com/rubygame/rubygame/), [Opal](https://github.com/opal/opal), [Ruboto](https://github.com/ruboto/ruboto) and [MobiRuby](https://github.com/mobiruby/mobiruby-ios) would allow games to target the desktop, web, and mobile using the same codebase.
-* The Ruby and game development communities are both particularly artistic as far as software development communities go.
+> Premature optimization is the root of all evil. - Donald Knuth
 
-So here's the plan
-------------------
-
-### Vector
-`Vector` instances represent position, distance, velocity, etc. For the sake of simplicity, all `Vector` instances are three-dimensional and missing components default to 0. This is not problematic for 2D game development because one can treat a three-dimensional vector with a third component of 0 as a two-dimensional vector in practice. `Vector` has method aliases for various synonyms and contexts.
-
-```ruby
-Vector[] #=> Vector[0, 0, 0]
-v1 = Vector[2, 4, 16] #=> Vector[2, 4, 16]
-v1[0] #=> 2
-v1.height #=> 4
-v1.z #=> 16
-v2 = Vector[1.5, 2] * 2 #=> Vector[3, 4, 0]
-v2.norm #=> 5
-v2.magnitude #=> 5
-v2.length #=> 5
-v2.distance #=> 5
-v2.speed #=> 5
-```
-
-### Entity
-`Entity` instances are objects that behave in the context of a `Game` instance. Each has a `Vector` `position`, and may have a `Vector` `size` and `Visual` `visual`. An `Entity` instance has an `update` method which is continuously called by its `Game` instance. `Entity` is meant to be built upon.
-
-```ruby
-class Paddle < Entity
-  def initialize(*args)
-    super(*args) # attach to Game instance and set up position
-    @visual = Image.new("gfx/paddle.png")
-    @speed = 5
-    @velocity = Vector[]
-  end
-
-  def update
-    @velocity.reset # same as `@velocity = Vector[0, 0, 0]`
-
-    if pressing? :left || pressing? :a # if the left arrow key or A key is pressed...
-      @velocity.x -= @speed # increase @velocity to the left
-    end
-
-    if pressing? :right || pressing? :d # if right arrow or D is pressed...
-      @velocity.x += @speed # increase @velocity to the right
-    end
-
-    if touching? Wall # if next to or intersecting a Wall...
-      unintersect Wall # fancy function to unintersect from any Wall
-      @velocity.reset # all of our previous button pressing was for naught
-    end
-
-    @position += @velocity # move (or perhaps not)
-  end
-end
-
-p = Paddle.new(20, 30) #=> Paddle at (20, 30, 0)
-p.position #=> Vector[20, 30, 0]
-p.y #=> 30 # method alias!
-```
-
-### Map
-Maps are Ruby hashes that can be parsed from JSON. Upon loading a map into a `Game` instance, the game looks for an `entities` key with a value of a hash with keys that correspond to `Entity` subclass names. Each of these keys have a value that is an array of up to 3 numeric elements or an array of said arrays. These numeric arrays represent coordinates at which to instantiate said `Entity` subclasses. Maps can also contain arbitrary data.
-
-```ruby
-level4 = {
-  entities: {
-    Teal: [10, 10], # instantiate Entity subclass Teal at (10, 10, 0)
-    Behemoth: [ # instantiate Behemoth at three different coordinates
-      [50, 10],
-      [100, 10],
-      [150, 10]
-    ]
-  },
-  name: "Level 4", # arbitrary data
-  time_limit: 300 # this too
-}
-```
-
-### Game
-A `Game` instance holds `Entity` instances in an `entities` array and runs their `update` methods on each frame. Assigning a map to `map` replaces `entities` with an array of new instances according to the map.
-
-```ruby
-g = Game.new #=> Game
-g.entities #=> []
-g.entities << Paddle.new #=> [Paddle]
-g.entities #=> [Paddle]
-g.map = level4
-g.entities #=> [Teal, Behemoth, Behemoth, Behemoth]
-```
+Planned features
+----------------
+* An opinionated, modular API that makes common tasks easy and everything else possible.
+* Command line initialization script to help one hit the ground running.
+* Graphical tools for creating video game resources like sprites and maps.
+* Multiple target platforms, starting with desktop and web.

data/demo/happy_rectangle.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# Happy Rectangle
+# A barebones demo for Yeah.
+
+lib = File.expand_path('../../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'yeah'
+include Yeah
+
+class HappyRectangle < Entity
+  def initialize(position)
+    super position
+    @visual = Rectangle.new(Vector[16, 24], Color[255, 255, 0, 255])
+    @updates = 0
+    @radius = 60
+    @center = (Game.new.resolution - @visual.size) / 2
+  end
+
+  def update
+    @updates += 1
+    @position.x = @center.x + (Math.cos(@updates) * @radius).floor
+    @position.y = @center.y + (Math.sin(@updates) * @radius).floor
+  end
+end
+
+class HappyRectangleGame < Game
+  def initialize
+    super
+    @updates = 0
+    @entities << HappyRectangle.new(resolution/2)
+  end
+
+  def update
+    super
+    @updates += 1
+    puts "#{@updates}/60 updates."
+    abort if @updates == 60
+  end
+end
+
+g = HappyRectangleGame.new
+g.start

data/lib/yeah/color.rb

@@ -0,0 +1,22 @@
+class Yeah::Color
+  attr_accessor :rgba_bytes
+
+  class << self
+    alias_method :[], :new
+  end
+
+  def initialize(*arguments)
+    arguments = [0, 0, 0, 255] if arguments.empty?
+
+    case arguments[0]
+    when Numeric
+      @rgba_bytes = [*arguments]
+    when Array
+      @rgba_bytes = arguments[0]
+    end
+  end
+
+  def ==(other)
+    self.class == other.class && @rgba_bytes == other.rgba_bytes ? true : false
+  end
+end

data/lib/yeah/desktop.rb

@@ -0,0 +1,34 @@
+require 'rubygame'
+
+class Yeah::Desktop
+  attr_reader :screen, :resolution, :tickrate
+
+  def initialize(resolution=Vector[320, 240])
+    self.resolution = resolution
+    @clock = Rubygame::Clock.new
+    self.tickrate = 30
+  end
+
+  def resolution=(value)
+    @screen = Rubygame::Screen.new(value.components[0..1])
+    @resolution = value
+  end
+
+  def render(surface)
+    struct = screen.send(:struct)
+    struct.pixels.write_string(surface.data(:bgra), surface.data.length)
+    screen.update
+  end
+
+  def tickrate=(value)
+    @clock.target_framerate = value
+    @tickrate = value
+  end
+
+  def each_tick
+    loop do
+      yield
+      @clock.tick
+    end
+  end
+end

data/lib/yeah/entity.rb

@@ -1,8 +1,8 @@
 class Yeah::Entity
-  attr_accessor :position
+  attr_accessor :position, :visual
 
-  def initialize(*position)
-    @position = Yeah::Vector[*position]
+  def initialize(position=Vector[])
+    @position = position
   end
 
   def x
@@ -28,4 +28,8 @@ class Yeah::Entity
   def z=(value)
     @position.z = value
   end
+
+  def draw
+    visual.draw if visual
+  end
 end

data/lib/yeah/game.rb

@@ -1,11 +1,30 @@
 class Yeah::Game
-  attr_accessor :entities
+  attr_accessor :entities, :screen, :platform, :resolution
 
   def initialize
+    @resolution = Vector[320, 240]
+    @screen = Surface.new(@resolution)
+    @platform = Desktop.new
     @entities = []
   end
 
   def update
     @entities.each { |e| e.update }
   end
+
+  def draw
+    screen.fill(Color[0, 0, 0, 0])
+    @entities.each do |entity|
+      surface = entity.draw
+      screen.draw(surface, entity.position) unless surface.nil?
+    end
+    platform.render(screen)
+  end
+
+  def start
+    platform.each_tick do
+      update
+      draw
+    end
+  end
 end

data/lib/yeah/map.rb

@@ -0,0 +1,7 @@
+class Yeah::Map
+  attr_accessor :background
+
+  def initialize
+    @background = Color[]
+  end
+end

data/lib/yeah/rectangle.rb

@@ -0,0 +1,14 @@
+class Yeah::Rectangle
+  attr_accessor :size, :color
+
+  def initialize(size=Vector[], color=Color[*[255]*4])
+    @size = size
+    @color = color
+  end
+
+  def draw
+    surface = Surface.new(size)
+    surface.fill(color)
+    surface
+  end
+end

data/lib/yeah/surface.rb

@@ -0,0 +1,59 @@
+class Yeah::Surface
+  attr_reader :size
+  attr_writer :data
+
+  def initialize(size=Vector[])
+    self.size = size
+  end
+
+  def size=(value)
+    @size = value
+    @data = "\x00" * 4 * size.x * size.y
+  end
+
+  def data(format=:rgba)
+    case format
+    when :rgba
+      @data
+    when :bgra
+      @data.scan(/.{4}/).map { |p| p[2] + p[1] + p[0] + p[3] }.join
+    end
+  end
+
+  def color_at(position)
+    data_lines = data.scan(/.{#{size.x*4}}/)
+    line = data_lines[position.y]
+    color_string = line[position.x*4..position.x*4+3]
+    color_bytes = color_string.unpack('H*')[0].
+      scan(/.{2}/).map { |b| b.to_i(16) }
+    Color[*color_bytes]
+  end
+
+  def fill(color, position1=Vector[0, 0], position2=size-1)
+    color_byte_string = color.rgba_bytes.pack('C*')
+    data_lines = data.scan(/.{#{size.x*4}}/)
+
+    rect_width = (position2.x - position1.x).abs + 1
+    (position1.y..position2.y).each do |i|
+      line = data_lines[i]
+      color_bytes_row = color_byte_string * rect_width
+      line[position1.x*4...(position2.x+1)*4] = color_bytes_row
+    end
+
+    @data = data_lines.join
+  end
+
+  def draw(surface, position=Vector[0, 0])
+    data_lines = data.scan(/.{#{size.x*4}}/)
+    surface_data_lines = surface.data.scan(/.{#{surface.size.x*4}}/)
+
+    (position.y...position.y+surface.size.height).each_with_index do |y, i|
+      line = data_lines[y]
+      surface_line = surface_data_lines[i]
+
+      line[position.x*4...(position.x+surface.size.width)*4] = surface_line
+    end
+
+    @data = data_lines.join
+  end
+end

data/lib/yeah.rb

@@ -1,7 +1,8 @@
 module Yeah
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end
 
-require 'yeah/vector'
-require 'yeah/entity'
-require 'yeah/game'
+requires = %i(vector color surface rectangle entity map desktop game)
+requires.each do |req|
+  require "yeah/#{req}"
+end

data/spec/color_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Color do
+  let(:klass) { described_class }
+  let(:instance) { klass.new }
+
+  it { klass.should be_kind_of Class }
+
+  [:new, :[]].each do |method_name|
+    describe "::#{method_name}" do
+      subject(:method) { klass.method(method_name) }
+
+      it { method.call.should be_instance_of klass }
+      it { method.call.rgba_bytes.should eq [0, 0, 0, 255] }
+      it { method.call([10, 20, 30, 40]).rgba_bytes.should eq [10, 20, 30, 40] }
+      it { method.call([55, 25, 55, 25]).rgba_bytes.should eq [55, 25, 55, 25] }
+      it { method.call(10, 20, 30, 40).rgba_bytes.should eq [10, 20, 30, 40] }
+      it { method.call(55, 25, 55, 25).rgba_bytes.should eq [55, 25, 55, 25] }
+    end
+  end
+
+  describe '#==' do
+    subject(:method) { instance.method(:==).unbind }
+
+    it "is true for itself" do
+      color = klass[55, 54, 53, 52]
+      method.bind(color).call(color).should eq true
+    end
+
+    it "is true for Color of same value" do
+      value = (1..4).map { Random.rand(255) }
+      method.bind(klass[value]).call(klass[value]).should eq true
+    end
+
+    it "is false for Color of different value" do
+      value = (1..4).map { Random.rand(255) }
+      method.bind(klass[value]).call(klass[value.reverse]).should eq false
+    end
+
+    it "is false for nil" do
+      method.bind(klass[]).call(nil).should eq false
+    end
+  end
+
+  describe '#rgba_bytes' do
+    subject(:rgba_bytes) { instance.rgba_bytes }
+
+    it { should eq [0, 0, 0, 255] }
+  end
+
+  describe '#rgba_bytes=' do
+    subject(:method) { instance.method(:rgba_bytes=) }
+
+    it_behaves_like 'writer', (1..4).map { Random.rand(255) }
+  end
+end

data/spec/desktop_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Desktop do
+  let(:klass) { described_class }
+  let(:instance) { klass.new }
+
+  it { klass.should be_instance_of Class }
+
+  describe '::new' do
+    subject(:method) { klass.method(:new) }
+
+    it { method.call.resolution.should eq Vector[320, 240] }
+
+    it "accepts Vector as resolution" do
+      vector = Vector[Random.rand(250), Random.rand(250)]
+      desktop = method.call(vector)
+      desktop.resolution.should eq vector
+      desktop.screen.size.should eq vector[0..1]
+    end
+
+    it { method.call.instance_variables.should include :@clock }
+    it do
+      clock = method.call.instance_variable_get(:@clock)
+      clock.should be_instance_of Rubygame::Clock
+    end
+  end
+
+  describe '#screen' do
+    subject { instance.screen }
+
+    it { should be_instance_of Rubygame::Screen }
+    its(:size) { should eq [320, 240] }
+  end
+
+  describe '#resolution' do
+    subject { instance.resolution }
+
+    it { should eq Vector[320, 240] }
+  end
+
+  describe '#resolution=' do
+    subject(:method) { instance.method(:resolution=) }
+
+    it_behaves_like 'writer', Vector[Random.rand(250), Random.rand(250)]
+
+    it "changes screen size" do
+      resolution = Vector[Random.rand(250)+1, Random.rand(250)+1]
+      method.call(resolution)
+      instance.screen.size.should eq resolution.components[0..1]
+    end
+  end
+
+  describe '#render' do
+    subject(:method) { instance.method(:render) }
+
+    it { expect { method.call }.to raise_error ArgumentError }
+
+    it "renders a Surface" do
+      surface = Surface.new(instance.resolution)
+      surface.fill(Color[255, 255, 0, 255], Vector[0, 0], Vector[1, 1])
+
+      screen_update_count = 0
+      allow(instance.screen).to receive(:update) { screen_update_count += 1 }
+
+      method.call(surface)
+      instance.screen.get_at([0, 0]).should eq [255, 255, 0, 255]
+      screen_update_count.should eq 1
+    end
+  end
+
+  describe '#each_tick' do
+    subject(:method) { instance.method(:each_tick) }
+
+    it { expect { method.call }.to raise_error LocalJumpError }
+
+    it "repeatedly calls passed block" do
+      call_count = 0
+
+      method.call do
+        call_count += 1
+        break if call_count == 5
+      end
+
+      call_count.should eq 5
+    end
+
+    it "calls Rubygame::Clock#tick per call" do
+      call_count = 0
+      tick_call_count = 0
+      allow(instance.instance_variable_get(:@clock)).to receive(:tick) do
+        tick_call_count += 1
+      end
+
+      method.call do
+        break if tick_call_count == 5
+        call_count += 1
+      end
+
+      call_count.should eq 5
+      tick_call_count.should eq 5
+    end
+  end
+
+  describe '#tickrate' do
+    subject { instance.tickrate }
+
+    its(:round) { should eq 30 }
+  end
+
+  describe '#tickrate=' do
+    subject(:method) { instance.method(:tickrate=) }
+
+    it_behaves_like 'writer', 60
+
+    it "sets @clock#target_framerate" do
+      tickrate = Random.rand(30) + 30
+      clock = instance.instance_variable_get(:@clock)
+      method.call(tickrate)
+
+      clock.target_framerate.round.should eq tickrate
+    end
+  end
+end

data/spec/entity_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Yeah::Entity do
-  let(:klass) { Yeah::Entity }
+describe Entity do
+  let(:klass) { described_class }
   let(:instance) { klass.new }
 
   it { klass.should be_instance_of Class }
@@ -10,23 +10,21 @@ describe Yeah::Entity do
     subject(:method) { klass.method(:new) }
 
     it { method.call.should be_instance_of klass }
-    it { method.call.position.should eq Yeah::Vector[0, 0, 0] }
-    it { method.call(2, 4, 8).position.should eq Yeah::Vector[2, 4, 8] }
+    it { method.call.position.should eq Vector[0, 0, 0] }
+    it { method.call(Vector[2, 4, 8]).position.should eq Vector[2, 4, 8] }
   end
 
   describe '#position' do
     subject(:position) { instance.position }
 
-    it { should be_instance_of Yeah::Vector }
+    it { should be_instance_of Vector }
     it { position.components.should eq [0, 0, 0] }
   end
 
   describe '#position=' do
-    it "assigns position" do
-      vector = Yeah::Vector[Random.rand(100)]
-      instance.position = vector
-      instance.position.should eq vector
-    end
+    subject(:method) { instance.method(:position=) }
+
+    it_behaves_like 'writer', Vector[Random.rand(100)]
   end
 
   [:x, :y, :z].each do |method_name|
@@ -45,4 +43,28 @@ describe Yeah::Entity do
       end
     end
   end
+
+  describe '#visual' do
+    subject { instance.visual }
+
+    it { should eq nil }
+  end
+
+  describe '#visual=' do
+    subject { instance.method(:visual=) }
+
+    it_behaves_like 'writer', Rectangle.new(Vector[50, 50])
+  end
+
+  describe '#draw' do
+    subject(:method) { instance.method(:draw) }
+
+    its(:call) { should eq nil }
+
+    it "calls #draw method of #visual if it exists" do
+      instance.visual = Rectangle.new
+      instance.visual.should receive(:draw)
+      method.call
+    end
+  end
 end

data/spec/game_spec.rb

@@ -1,11 +1,29 @@
 require 'spec_helper'
 
-describe Yeah::Game do
-  let(:klass) { Yeah::Game }
+describe Game do
+  let(:klass) { described_class }
   let(:instance) { klass.new }
 
   it { klass.should be_instance_of Class }
 
+  describe '#platform' do
+    subject { instance.platform }
+
+    it { should be_instance_of Desktop }
+  end
+
+  describe '#resolution' do
+    subject { instance.resolution }
+
+    it { should eq Vector[320, 240] }
+  end
+
+  describe '#resolution=' do
+    subject { instance.method(:resolution=) }
+
+    it_behaves_like 'writer', Vector[512, 384]
+  end
+
   describe '#entities' do
     subject(:entities) { instance.entities }
 
@@ -13,20 +31,73 @@ describe Yeah::Game do
   end
 
   describe '#entities=' do
-    it "assigns #entities" do
-      value = [Yeah::Entity.new(Random.rand(100))]
-      instance.entities = value
-      instance.entities.should eq value
-    end
+    subject(:method) { instance.method(:entities=) }
+
+    it_behaves_like 'writer', [Entity.new(Random.rand(10))]
   end
 
   describe '#update' do
+    subject(:method) { instance.method(:update) }
+
     it "calls #update of each element in #entities" do
-      instance.entities = (1..3).map { DummyEntity.new }
-      update_count = Random.rand(5)
-      update_count.times { instance.update }
+      instance.entities = (1..3).map { Entity.new }
+      instance.entities.each { |e| e.should receive(:update) }
+      method.call
+    end
+  end
+
+  describe '#draw' do
+    subject(:method) { instance.method(:draw) }
+
+    it "clears #screen" do
+      instance.screen.should receive(:fill).with(Color[0, 0, 0, 0])
+      method.call
+    end
+
+    it "calls #draw of each element in #entities" do
+      instance.entities = (1..3).map { Entity.new }
+      instance.entities.each { |e| e.should receive(:draw) }
+      method.call
+    end
+
+    it "draws entities on #screen" do
+      color = Color[0, 255, 0, 255]
+      entity = Entity.new
+      entity.visual = Rectangle.new(Vector[1, 1], color)
+      entity.position = Vector[Random.rand(10), Random.rand(10)]
+      instance.entities << entity
+      method.call
+
+      instance.screen.color_at(entity.position).should eq color
+    end
+
+    it "writes to #platform#screen#struct#pixels" do
+      pixels = instance.platform.screen.send(:struct).pixels
+      pixel_data = pixels.read_string(instance.screen.data.length)
+      pixel_data.should eq instance.screen.data
+    end
+
+    it "calls #platform#screen#update" do
+      instance.platform.screen.should receive(:update)
+      method.call
+    end
+  end
+
+  describe '#screen' do
+    subject(:screen) { instance.screen }
+
+    it { should be_instance_of Surface }
+    its(:size) { should eq instance.resolution }
+  end
+
+  describe '#start' do
+    subject(:method) { instance.method(:start) }
 
-      instance.entities.each { |e| e.update_count.should eq update_count }
+    it "calls #platform#each_tick with a block with #update and #draw calls" do
+      instance.platform.instance_eval "def each_tick; yield; end"
+      instance.should receive(:update)
+      instance.should receive(:draw)
+      method.call
     end
   end
 end

data/spec/map_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Map do
+  let(:klass) { described_class }
+  let(:instance) { klass.new }
+
+  it { klass.should be_instance_of Class }
+
+  describe '#background' do
+    subject(:background) { instance.background }
+
+    it { should eq Color[] }
+  end
+
+  describe '#background=' do
+    subject(:method) { instance.method(:background=) }
+
+    it_behaves_like 'writer', Color[*[Random.rand(255)]*4]
+  end
+end

data/spec/rectangle_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Rectangle do
+  let(:klass) { described_class }
+  let(:instance) { klass.new }
+
+  it { klass.should be_kind_of Class }
+
+  describe '::new' do
+    subject(:method) { klass.method(:new) }
+
+    it { method.call.should be_instance_of klass }
+    it { method.call.size.should eq Vector[] }
+    it { method.call.color.should eq Color[255, 255, 255, 255] }
+
+    it "assigns Vector first argument as #size" do
+      vector = Vector[Random.rand(40)]
+      method.call(vector).size.should eq vector
+    end
+
+    it "assigns second argument Color as #color" do
+      byte_array = (1..4).map { Random.rand(255) }
+      color = Color[*byte_array]
+      method.call(Vector[], color).color.should eq color
+    end
+  end
+
+  describe '#size' do
+    subject(:size) { instance.size }
+
+    it { should eq Vector[] }
+  end
+
+  describe '#size=' do
+    subject(:method) { instance.method(:size=) }
+
+    it_behaves_like 'writer', Vector[Random.rand(40)]
+  end
+
+  describe '#color' do
+    subject(:color) { instance.color }
+
+    it { should eq Color[255, 255, 255, 255] }
+  end
+
+  describe '#color=' do
+    subject(:method) { instance.method(:color=) }
+
+    it_behaves_like 'writer', Color[*[Random.rand(255)]*4]
+  end
+
+  describe '#draw' do
+    subject(:method) { instance.method(:draw) }
+
+    its(:call) { should be_instance_of Surface }
+
+    it "matches size" do
+      instance.size = Vector[Random.rand(49)+1, 50]
+      method.call.size.should eq instance.size
+    end
+
+    it "matches color" do
+      instance.size = Vector[10, 10]
+      instance.color = Color[*[Random.rand(255)]*4]
+      surface = method.call
+      surface.color_at(Vector[]).should eq instance.color
+      surface.color_at(instance.size/2).should eq instance.color
+      surface.color_at(instance.size-Vector[1, 1]).should eq instance.color
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,14 +1,13 @@
 require 'yeah'
+include Yeah
 
-class DummyEntity < Yeah::Entity
-  attr_reader :update_count
+shared_examples 'writer' do |value|
+  it "assigns its reader" do
+    writer = subject
+    reader_name = writer.name[0..-2].to_sym
+    reader = writer.receiver.method(reader_name)
 
-  def initialize
-    super
-    @update_count = 0
-  end
-
-  def update
-    @update_count += 1
+    writer.call(value)
+    reader.call.should eq value
   end
 end

data/spec/surface_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Surface do
+  let(:klass) { described_class }
+  let(:vector) { Vector[Random.rand(48)+2, Random.rand(48)+2] }
+  let(:instance) { klass.new(vector) }
+
+  describe '::new' do
+    subject(:method) { klass.method :new }
+
+    it { method.call.size.should eq Vector[] }
+
+    it "accepts a Vector size" do
+      surface = method.call(vector)
+      surface.size.should eq vector
+    end
+  end
+
+  describe '#size' do
+    subject { instance.size }
+
+    it { should eq vector }
+  end
+
+  describe '#size=' do
+    subject(:method) { instance.method(:size=) }
+
+    it_behaves_like 'writer', Vector[20, 20]
+  end
+
+  describe '#data' do
+    subject(:method) { instance.method(:data) }
+    let(:data) { instance.data }
+
+    it "has length of #size.x * #size.y * 4" do
+      instance.size = instance.size * 2
+      expected_length = instance.size.x * instance.size.y * 4
+      data.length.should eq expected_length
+    end
+
+    it "is a series of \x00\x00\x00\x00 by default" do
+      pixels = data.unpack('H*')[0].scan(/.{8}/)
+      pixels.uniq.size.should eq 1
+      pixels.uniq.last.should eq "00000000"
+    end
+
+    it "accepts format param" do
+      instance.data = "\x00\x11\x22\x33"
+      method.call(:rgba).should eq "\x00\x11\x22\x33"
+      method.call(:bgra).should eq "\x22\x11\x00\x33"
+    end
+  end
+
+  describe '#data=' do
+    subject(:method) { instance.method(:data=) }
+
+    it "assigns hex data of length size.x * size.y * 4" do
+      data = "\xFF" * instance.size.x * instance.size.y * 4
+      method.call(data)
+      instance.data.should eq data
+    end
+  end
+
+  describe '#color_at' do
+    subject(:method) { instance.method(:color_at) }
+
+    it { expect { method.call }.to raise_error ArgumentError }
+
+    it "matches the color of the pixel at position" do
+      method.call(vector/2).should eq Color[0, 0, 0, 0]
+    end
+  end
+
+  describe '#fill' do
+    subject(:method) { instance.method(:fill) }
+    let(:color2) { Color[0, 255, 0, 255] }
+
+    it { expect { method.call }.to raise_error ArgumentError }
+
+    it "changes color of rectangular area with position args" do
+      method.call(color2, Vector[], vector/2)
+      instance.color_at(Vector[]).should eq color2
+      instance.color_at(vector/2).should eq color2
+      instance.color_at(vector/2 + Vector[1, 0]).should eq Color[0, 0, 0, 0]
+      instance.color_at(vector/2 + Vector[0, 1]).should eq Color[0, 0, 0, 0]
+      instance.data.length.should eq instance.size.x * instance.size.y * 4
+    end
+
+    it "changes color of entire surface without position args" do
+      method.call(color2)
+      instance.color_at(Vector[]).should eq color2
+      instance.color_at(vector/2).should eq color2
+      instance.color_at(vector-1).should eq color2
+      instance.data.length.should eq instance.size.x * instance.size.y * 4
+    end
+  end
+
+  describe '#draw' do
+    subject(:method) { instance.method(:draw) }
+    let(:color) { Color[0, Random.rand(255), Random.rand(255), 255] }
+
+    it { expect { method.call }.to raise_error ArgumentError }
+
+    it "draws surface at position" do
+      surface = Surface.new(Vector[1, 1])
+      surface.fill(color)
+      surface2 = Surface.new(Vector[10, 10])
+      surface2.draw(surface, Vector[1, 1])
+
+      surface2.color_at(Vector[0, 0]).should eq Color[0, 0, 0, 0]
+      surface2.color_at(Vector[1, 1]).should eq color
+      surface2.color_at(Vector[2, 2]).should eq Color[0, 0, 0, 0]
+    end
+
+    it "draws surface at (0, 0) by default" do
+      surface = Surface.new(Vector[1, 1])
+      surface.fill(color)
+      surface2 = Surface.new(Vector[10, 10])
+      surface2.draw(surface)
+
+      surface2.color_at(Vector[0, 0]).should eq color
+      surface2.color_at(Vector[1, 1]).should eq Color[0, 0, 0, 0]
+    end
+
+    it "draws a rectangular area" do
+      surface = Surface.new(Vector[3, 3])
+      surface.fill(color)
+      surface2 = Surface.new(Vector[5, 5])
+      surface2.draw(surface, Vector[1, 1])
+
+      surface2.color_at(Vector[1, 1]).should eq color
+      surface2.color_at(Vector[1, 3]).should eq color
+      surface2.color_at(Vector[3, 1]).should eq color
+      surface2.color_at(Vector[3, 3]).should eq color
+      surface2.color_at(Vector[0, 3]).should eq Color[0, 0, 0, 0]
+      surface2.color_at(Vector[3, 0]).should eq Color[0, 0, 0, 0]
+      surface2.color_at(Vector[4, 3]).should eq Color[0, 0, 0, 0]
+      surface2.color_at(Vector[3, 4]).should eq Color[0, 0, 0, 0]
+    end
+  end
+end

data/spec/vector_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Yeah::Vector do
-  let(:klass) { Yeah::Vector }
-  let(:arguments) { (1..3).map { Random.rand(100) } }
+describe Vector do
+  let(:klass) { described_class }
+  let(:arguments) { (1..3).map { Random.rand(100)+1 } }
   let(:instance) { klass.new(*arguments) }
 
   it { klass.should be_instance_of Class }
@@ -104,10 +104,10 @@ describe Yeah::Vector do
 
     it "subtracts Numeric" do
       subtrahend = Random.rand(100)
-      difference = instance + subtrahend
+      difference = instance - subtrahend
 
       difference.components.each_with_index do |component, i|
-        component.should eq instance.components[i] + subtrahend
+        component.should eq instance.components[i] - subtrahend
       end
     end
   end
@@ -144,7 +144,7 @@ describe Yeah::Vector do
     end
 
     it "divides by Numeric" do
-      divisor = Random.rand(100)
+      divisor = Random.rand(100) + 1
       quotient = instance / divisor
 
       quotient.components.each_with_index do |component, i|

data/spec/yeah_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
 describe Yeah do
-  it "is a Module" do
-    Yeah.should be_instance_of Module
-  end
+  let(:modjul) { described_class }
+
+  it { modjul.should be_instance_of Module }
 
   describe '::VERSION' do
-    subject { Yeah::VERSION }
+    subject { modjul::VERSION }
 
     it { should be_instance_of String }
     it { should match /[0-9]+\.[0-9]+\.[0-9]+/ }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yeah
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Artur Ostrega
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-05 00:00:00.000000000 Z
+date: 2013-09-22 00:00:00.000000000 Z
 dependencies: []
 description: Programming video games should have a positive impact on your health!
 email: skoofoo@gmail.com
@@ -18,18 +18,30 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - Guardfile
+- lib/yeah/map.rb
 - lib/yeah/game.rb
+- lib/yeah/color.rb
+- lib/yeah/surface.rb
 - lib/yeah/vector.rb
+- lib/yeah/desktop.rb
+- lib/yeah/rectangle.rb
 - lib/yeah/entity.rb
 - lib/yeah.rb
 - README.md
-- yeah-0.0.2.gem
+- CHANGELOG.md
 - tmp/rspec_guard_result
 - Gemfile.lock
 - yeah.gemspec
 - LICENSE.txt
+- demo/happy_rectangle.rb
+- yeah-0.1.0.gem
 - spec/yeah_spec.rb
+- spec/color_spec.rb
+- spec/desktop_spec.rb
 - spec/game_spec.rb
+- spec/rectangle_spec.rb
+- spec/surface_spec.rb
+- spec/map_spec.rb
 - spec/spec_helper.rb
 - spec/entity_spec.rb
 - spec/vector_spec.rb