yeah 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0c6e5215bc7f40ed78d1fba8db16ff7b0adf9d3
+  data.tar.gz: ddc2c5ebf36519ba42d7ddffd788dc4d20092534
+SHA512:
+  metadata.gz: 00dcbd4572d660d377624cc12b49412ef26b56844734c3bd43fe93fb24049179531fd956ed63aef47e584b48accbe465239cf5747663ab98db2a9d2773ab206e
+  data.tar.gz: 50f5ad56743ee6291682f66302cdddb75931502f2a205926dce1041b3012ee6df461453d5f9bbcd00c8d22f71e04f996b4202bf0cf7a12ee0cf83804ee44f30c

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'guard-rspec'
+gem 'libnotify'

data/Gemfile.lock

@@ -0,0 +1,51 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.0.9)
+    diff-lcs (1.2.4)
+    ffi (1.9.0)
+    formatador (0.2.4)
+    guard (1.8.1)
+      formatador (>= 0.2.4)
+      listen (>= 1.0.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-rspec (3.0.2)
+      guard (>= 1.8)
+      rspec (~> 2.13)
+    libnotify (0.8.1)
+      ffi (>= 1.0.11)
+    listen (1.2.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    lumberjack (1.0.4)
+    method_source (0.8.1)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.0)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    slop (3.4.5)
+    thor (0.18.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard-rspec
+  libnotify
+  rspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec, cli: "--color" do
+  watch('spec/spec_helper.rb')
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib(\/yeah)?\/(.+)\.rb$}) { |m| "spec/#{m[2]}_spec.rb" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Artur Ostrega
+
+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,99 @@
+Yeah
+====
+The positive video game framework
+
+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.
+
+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]
+```

data/lib/yeah/entity.rb

@@ -0,0 +1,31 @@
+class Yeah::Entity
+  attr_accessor :position
+
+  def initialize(*position)
+    @position = Yeah::Vector[*position]
+  end
+
+  def x
+    @position.x
+  end
+
+  def x=(value)
+    @position.x = value
+  end
+
+  def y
+    @position.y
+  end
+
+  def y=(value)
+    @position.y = value
+  end
+
+  def z
+    @position.z
+  end
+
+  def z=(value)
+    @position.z = value
+  end
+end

data/lib/yeah/game.rb

@@ -0,0 +1,11 @@
+class Yeah::Game
+  attr_accessor :entities
+
+  def initialize
+    @entities = []
+  end
+
+  def update
+    @entities.each { |e| e.update }
+  end
+end

data/lib/yeah/vector.rb

@@ -0,0 +1,130 @@
+class Yeah::Vector
+  class << self
+    alias_method :[], :new
+  end
+
+  def initialize(*components)
+    if components.size > 3
+      error_message = "too many arguments (#{components.size} for up to 3)"
+      raise ArgumentError, error_message
+    end
+
+    self.components = components
+  end
+
+  def components
+    @components
+  end
+
+  def components=(values)
+    if values.size > 3
+      error_message = "too many elements (#{values.size} for up to 3)"
+      raise ArgumentError, error_message
+    end
+
+    @components = values + [0] * (3 - values.size)
+  end
+
+  def ==(other)
+    other.class == self.class && @components == other.components ? true : false
+  end
+
+  def [](index)
+    @components[index]
+  end
+
+  def []=(index, value)
+    @components[index] = value
+  end
+
+  def +(addend)
+    case addend
+    when self.class
+      comp_addends = addend.components
+    when Numeric
+      comp_addends = [addend] * 3
+    end
+    components = @components.zip(comp_addends).map { |c| c.reduce(:+) }
+
+    self.class[*components]
+  end
+
+  def -(subtrahend)
+    case subtrahend
+    when self.class
+      comp_subtrahends = subtrahend.components
+    when Numeric
+      comp_subtrahends = [subtrahend] * 3
+    end
+    components = @components.zip(comp_subtrahends).map { |c| c.reduce(:-)}
+
+    self.class[*components]
+  end
+
+  def *(multiple)
+    case multiple
+    when self.class
+      comp_multiples = multiple.components
+    when Numeric
+      comp_multiples = [multiple] * 3
+    end
+
+    components = @components.zip(comp_multiples).map { |c| c.reduce(:*) }
+    self.class[*components]
+  end
+
+  def /(divisor)
+    case divisor
+    when self.class
+      comp_divisors = divisor.components
+    when Numeric
+      comp_divisors = [divisor] * 3
+    end
+
+    components = @components.zip(comp_divisors).map { |c| c.reduce(:/) }
+    self.class[*components]
+  end
+
+  def x
+    @components[0]
+  end
+  alias_method :width, :x
+
+  def y
+    @components[1]
+  end
+  alias_method :height, :y
+
+  def z
+    @components[2]
+  end
+  alias_method :depth, :z
+
+  def x=(value)
+    @components[0] = value
+  end
+  alias_method :width=, :x=
+
+  def y=(value)
+    @components[1] = value
+  end
+  alias_method :height=, :y=
+
+  def z=(value)
+    @components[2] = value
+  end
+  alias_method :depth=, :z=
+
+  def norm
+    Math.sqrt(@components.reduce(0) { |m, c| m + c*c })
+  end
+  alias_method :magnitude, :norm
+  alias_method :length, :norm
+  alias_method :distance, :norm
+  alias_method :speed, :norm
+
+  def reset
+    @components = [0, 0, 0]
+    self
+  end
+end

data/lib/yeah.rb

@@ -0,0 +1,7 @@
+module Yeah
+  VERSION = '0.1.0'
+end
+
+require 'yeah/vector'
+require 'yeah/entity'
+require 'yeah/game'

data/spec/entity_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Yeah::Entity do
+  let(:klass) { Yeah::Entity }
+  let(:instance) { klass.new }
+
+  it { klass.should be_instance_of Class }
+
+  describe '::new' 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] }
+  end
+
+  describe '#position' do
+    subject(:position) { instance.position }
+
+    it { should be_instance_of Yeah::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
+  end
+
+  [:x, :y, :z].each do |method_name|
+    describe "##{method_name}" do
+      it "is #position.#{method_name}" do
+        instance.position.send("#{method_name}=", Random.rand(100))
+        instance.send(method_name).should eq instance.position.send(method_name)
+      end
+    end
+
+    describe "##{method_name}=" do
+      it "assigns #position.#{method_name}" do
+        value = Random.rand(100)
+        instance.send("#{method_name}=", value)
+        instance.position.send(method_name).should eq value
+      end
+    end
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Yeah::Game do
+  let(:klass) { Yeah::Game }
+  let(:instance) { klass.new }
+
+  it { klass.should be_instance_of Class }
+
+  describe '#entities' do
+    subject(:entities) { instance.entities }
+
+    it { should eq [] }
+  end
+
+  describe '#entities=' do
+    it "assigns #entities" do
+      value = [Yeah::Entity.new(Random.rand(100))]
+      instance.entities = value
+      instance.entities.should eq value
+    end
+  end
+
+  describe '#update' do
+    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.each { |e| e.update_count.should eq update_count }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'yeah'
+
+class DummyEntity < Yeah::Entity
+  attr_reader :update_count
+
+  def initialize
+    super
+    @update_count = 0
+  end
+
+  def update
+    @update_count += 1
+  end
+end

data/spec/vector_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe Yeah::Vector do
+  let(:klass) { Yeah::Vector }
+  let(:arguments) { (1..3).map { Random.rand(100) } }
+  let(:instance) { klass.new(*arguments) }
+
+  it { klass.should be_instance_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.components.should eq [0, 0, 0] }
+      it { method.call(4, 5, 6).components.should eq [4, 5, 6] }
+      it { method.call(8, 9).components.should eq [8, 9, 0] }
+      it { method.call(7).components.should eq [7, 0, 0] }
+
+      it "complains with 4 arguments" do
+        expect { method.call(7, 8, 9, 10) }.
+          to raise_error ArgumentError, /too many arguments/
+      end
+    end
+  end
+
+  describe '#components' do
+    subject(:components) { instance.components }
+
+    it { should be_instance_of Array }
+    it { should have(3).elements }
+    it { components.each { |c| c.should be_kind_of Numeric } }
+  end
+
+  describe '#components=' do
+    it "assigns array of up to 3 elements and uses 0 for missing elements" do
+      instance.components = [4, 5, 6]
+      instance.components.should eq [4, 5, 6]
+
+      instance.components = [8, 9]
+      instance.components.should eq [8, 9, 0]
+
+      instance.components = []
+      instance.components.should eq [0, 0, 0]
+    end
+
+    it "complains with 4-element array" do
+      expect { instance.components = [7, 8, 9, 10] }.
+        to raise_error ArgumentError, /too many elements/
+    end
+  end
+
+  describe '#==' do
+    it { (instance == klass[*instance.components]).should eq true }
+    it { (instance == klass[*instance.components.reverse]).should eq false }
+    it { (instance == nil).should eq false }
+  end
+
+  describe '#[]' do
+    it { instance[0].should eq arguments[0] }
+    it { instance[1].should eq arguments[1] }
+    it { instance[2].should eq arguments[2] }
+  end
+
+  describe '#[]=' do
+    it "assigns n component" do
+      3.times do |i|
+        instance[i] = instance[i] + 5
+        instance[i].should eq arguments[i] + 5
+      end
+    end
+  end
+
+  describe '#+' do
+    it "adds Vector" do
+      sum = instance + instance
+      sum.components.each_with_index do |component, i|
+        component.should eq instance.components[i] * 2
+      end
+    end
+
+    it "adds Numeric" do
+      addend = Random.rand(100)
+      sum = instance + addend
+
+      sum.components.each_with_index do |component, i|
+        component.should eq instance.components[i] + addend
+      end
+    end
+  end
+
+  describe '#-' do
+    it "subtracts Vector" do
+      difference = instance - instance
+      difference.components.each do |component|
+        component.should eq 0
+      end
+
+      difference2 = difference - instance
+      difference2.components.each_with_index do |component, i|
+        component.should eq -instance.components[i]
+      end
+    end
+
+    it "subtracts Numeric" do
+      subtrahend = Random.rand(100)
+      difference = instance + subtrahend
+
+      difference.components.each_with_index do |component, i|
+        component.should eq instance.components[i] + subtrahend
+      end
+    end
+  end
+
+  describe '#*' do
+    it "multiplies by Vector" do
+      product = instance * instance
+      product.components.each_with_index do |component, i|
+        component.should eq instance.components[i] ** 2
+      end
+    end
+
+    it "multiplies by Numeric" do
+      multiple = Random.rand(100)
+      product = instance * multiple
+
+      product.components.each_with_index do |component, i|
+        component.should eq instance.components[i] * multiple
+      end
+    end
+  end
+
+  describe '#/' do
+    it "divides by Vector" do
+      quotient = instance / instance
+      quotient.components.each do |component|
+        component.should eq 1
+      end
+
+      quotient2 = instance / quotient
+      quotient2.components.each_with_index do |component, i|
+        component.should eq instance.components[i]
+      end
+    end
+
+    it "divides by Numeric" do
+      divisor = Random.rand(100)
+      quotient = instance / divisor
+
+      quotient.components.each_with_index do |component, i|
+        component.should eq instance.components[i] / divisor
+      end
+    end
+  end
+
+  [
+    [:x, :width],
+    [:y, :height],
+    [:z, :depth]
+  ].each_with_index do |method_name_set, i|
+    method_name_set.each do |method_name|
+      describe "##{method_name}" do
+        subject(:method) { instance.method(method_name) }
+
+        it { method.call.should eq instance[i] }
+      end
+
+      describe "#{method_name}=" do
+        subject(:method) { instance.method("#{method_name}=") }
+
+        it "assigns value" do
+          value = Random.rand(100)
+          method.call(value)
+          instance[i].should eq value
+        end
+      end
+    end
+  end
+
+  [:norm, :magnitude, :length, :distance, :speed].each do |method_name|
+    describe "##{method_name}" do
+      it { klass.new(3, 4).method(method_name).call.should eq 5 }
+      it { klass.new(6, 8).method(method_name).call.should eq 10 }
+    end
+  end
+
+  describe '#reset' do
+    it "sets components to 0" do
+      instance.reset
+      instance.components.should eq [0, 0, 0]
+    end
+
+    it "returns itself" do
+      instance.reset.should eq instance
+    end
+  end
+end

data/spec/yeah_spec.rb

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

data/tmp/rspec_guard_result

@@ -0,0 +1 @@
+

data/yeah.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'yeah'
+
+Gem::Specification.new do |s|
+  s.name = 'yeah'
+  s.version = Yeah::VERSION
+  s.summary = "The positive video game framework"
+  s.description = "Programming video games should have a positive impact on your health!"
+  s.authors = ["Artur Ostrega"]
+  s.email = 'skoofoo@gmail.com'
+  s.files = Dir.glob('**/*')
+  s.license = 'MIT'
+  s.homepage = 'https://github.com/skofo/yeah'
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: yeah
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Artur Ostrega
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-05 00:00:00.000000000 Z
+dependencies: []
+description: Programming video games should have a positive impact on your health!
+email: skoofoo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Guardfile
+- lib/yeah/game.rb
+- lib/yeah/vector.rb
+- lib/yeah/entity.rb
+- lib/yeah.rb
+- README.md
+- yeah-0.0.2.gem
+- tmp/rspec_guard_result
+- Gemfile.lock
+- yeah.gemspec
+- LICENSE.txt
+- spec/yeah_spec.rb
+- spec/game_spec.rb
+- spec/spec_helper.rb
+- spec/entity_spec.rb
+- spec/vector_spec.rb
+homepage: https://github.com/skofo/yeah
+licenses:
+- MIT
+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.0.5
+signing_key: 
+specification_version: 4
+summary: The positive video game framework
+test_files: []