tsuku 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bfd429da0b770c819bc22a8ac2d20b916a7c39aee53ad8f309d608c68399b0e
-  data.tar.gz: 64c79f6f3704bd322c27c85bbbea6713eeb48db4fc434363860f02f38ed39147
+  metadata.gz: 58899b47564289ea7e5d15ddb7b1a07431fa327d52005076d0c28cf010f64998
+  data.tar.gz: 3c4055edc536c72b8e85d76e86d361934c52d2feebcf734038589e5f2b1812f0
 SHA512:
-  metadata.gz: f80cb14e286cd41964a355be0de81e6faf49783e297b94c04928b1991a4844c500be97612d7f0dc2b3506fcf0377db4f4693dfc2ac715caccfc7f65ae5d1d2ed
-  data.tar.gz: 3acfc46de978fe92db5ed5c217e9e46777a45cdd74a477b64651b64c730cc82cdd9375cb494f5084babdfca982facb1b4937ff9a60456da43a769b585203fc82
+  metadata.gz: 41b4c15a7d9d440e317539a34e26bad40377df61911ff94d5b21251c8108433fe1cec65055a8ff2424f709b9829b4ef84b0390af75f74d15613cda306a75323b
+  data.tar.gz: a014b2f37d1cbd55343759fa0160c5f8e7db204410717165fddad6608834019772f9cc836ae2635911463ce2e7e0ab36ffb1e198817cb71b6e8c920cc0afaf03

data/README.md

@@ -1,2 +1,66 @@
 # tsuku
 A tweening tool written in Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem 'tsuku'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tsuku
+
+## Usage
+
+The recommended way to use Tsuku is to interface with the `Tweener` class.
+First, make sure to call the `step` method in your main update loop. You will
+need to provide the number of milliseconds that have elapsed since the previous
+frame:
+
+```ruby
+def game_update_loop
+    ...
+    
+    Tweener.step(delta_ms)
+
+    ...
+end
+```
+
+Then use `add_tween` to create tweens as needed. For example, this tween changes
+the player's x and y coordinates over a span of 3000 milliseconds:
+
+```ruby
+Tweener.add_tween(player, { x: 10, y: 5 }, 3000)
+```
+
+Any tweens created with `Tweener` will start and be cleaned up automatically.
+If you need greater control, you can create a `Tween` manually like so:
+
+```ruby
+@tween = Tsuku::Tween.new(player, { x: 10, y: 5 }, 3000)
+@tween.start
+```
+
+Now in your game update loop, advance the tween by calling its `step` method:
+
+```ruby
+@tween.step(delta_ms)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/jtuttle/tsuku.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).

data/lib/tsuku/tween.rb

@@ -1,17 +1,16 @@
 module Tsuku
   class Tween
-    def initialize(target, final_property_values, duration_ms, easing: :linear)
+    def initialize(target, final_property_values, duration_ms, easing = :linear)
       @target = target
       @final_property_values = final_property_values
       @duration_ms = duration_ms
       @easing = easing
 
       @running = false
+      @elapsed_ms = 0.0
     end
     
     def start
-      @elapsed_ms = 0.0
-
       @initial_property_values = {}
 
       @final_property_values.each_key do |k|
@@ -34,6 +33,22 @@ module Tsuku
       advance_property_values
     end
 
+    def pause
+      @running = false
+    end
+
+    def resume
+      @running = true unless completed?
+    end
+
+    def reset
+      @elapsed_ms = 0
+    end
+
+    def completed?
+      @elapsed_ms >= @duration_ms
+    end
+
     private
     
     def advance_property_values

data/lib/tsuku/tweener.rb

@@ -0,0 +1,50 @@
+require 'singleton'
+require 'forwardable'
+
+module Tsuku
+  class Tweener
+    include Singleton
+
+    def initialize
+      super
+      
+      @tweens = []
+      @running = true
+    end
+    
+    def add_tween(target, final_property_values, duration_ms, easing = :linear)
+      tween = Tween.new(target, final_property_values, duration_ms, easing)
+      tween.start
+      
+      @tweens << tween
+    end
+
+    def step(delta_ms)
+      return if !@running
+
+      @tweens.reverse_each do |tween|
+        tween.step(delta_ms)
+
+        if tween.completed?
+          @tweens.delete(tween)
+        end
+      end
+    end
+
+    def pause
+      @running = false
+    end
+
+    def resume
+      @running = true
+    end
+
+    class << self
+      extend Forwardable
+
+      # delegate all instance methods to singleton instance to allow calling
+      # methods without '.instance' (i.e. Tweener.add_tween)
+      def_delegators :instance, *Tweener.instance_methods(false)
+    end
+  end
+end

data/lib/tsuku/version.rb

@@ -1,3 +1,3 @@
 module Tsuku
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/easing_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Tsuku::Easing do
+  let(:elapsed_ms) { 500 }
+  let(:duration_ms) { 1000 }
+  let(:initial_value) { 10 }
+  let(:final_value) { 20 }
+  let(:value_delta) { final_value - initial_value }
+  
+  it "computes linear easing correctly" do
+    value = Tsuku::Easing.linear(
+      elapsed_ms,
+      initial_value,
+      value_delta,
+      duration_ms
+    )
+
+    expect(value).to eq(15)
+  end
+end

data/spec/tween_spec.rb

@@ -4,31 +4,63 @@ RSpec.describe Tsuku::Tween do
   let(:target) { MockTarget.new(x: 1, y: 2, z: 3) }
   
   let(:tween) { Tsuku::Tween.new(target, { x: 10, y: -10, z: 3 }, 1000) }
+
+  it "does not advance if start was not called" do
+    tween.step(1000)
+    expect(target.x).to eq(1)
+  end
   
-  it "tweens correctly in positive direction" do
+  it "advances correctly when tweening in positive direction" do
     tween.start
     tween.step(1000)
     expect(target.x).to eq(10)
   end
 
-  it "tweens correctly in negative direction" do
+  it "advances correctly when tweening in negative direction" do
     tween.start
     tween.step(1000)
     expect(target.y).to eq(-10)
   end
 
-  it "tweens correctly when target property does not change" do
+  it "advances correctly when target and initial values are the same" do
     tween.start
     tween.step(1000)
     expect(target.z).to eq(3)
   end
   
-  it "does not tween past target value" do
+  it "does not tween past the target value" do
     tween.start
     tween.step(5000)
     expect(target.x).to eq(10)
   end
 
+  it "does not advance when paused" do
+    tween.start
+    tween.step(500)
+    tween.pause
+    tween.step(500)
+    expect(target.x).to eq(5.5)
+  end
+
+  it "resumes correctly after being paused and resumed" do
+    tween.start
+    tween.pause
+    tween.resume
+    tween.step(500)
+    expect(target.x).to eq(5.5)
+  end
+
+  it "advances correctly after being completed and reset" do
+    tween.start
+    tween.step(1000)
+
+    target.x = 0
+    tween.reset
+    tween.start
+    tween.step(500)
+    expect(target.x).to eq(5)
+  end
+
   it "tweens correctly when property value changes after tween initialization" do
     target.x = 50
     tween.start
@@ -36,9 +68,15 @@ RSpec.describe Tsuku::Tween do
     expect(target.x).to eq(10)
   end
 
-  it "computes intermediate value correctly (linear easing)" do
-    tween.start
-    tween.step(500)
-    expect(target.x).to eq(5.5)
+  describe "#completed?" do
+    it "returns false when tween is not completed" do
+      expect(tween.completed?).to eq(false)
+    end
+    
+    it "returns true when tween is completed" do
+      tween.start
+      tween.step(1000)
+      expect(tween.completed?).to eq(true)
+    end
   end
 end

data/spec/tweener_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+RSpec.describe Tsuku::Tweener do
+  let(:target) { MockTarget.new(x: 1, y: 2, z: 3) }
+
+  before do
+    Tsuku::Tweener.add_tween(target, { x: 10 }, 1000)
+    Tsuku::Tweener.add_tween(target, { y: 10 }, 2000)
+  end
+  
+  it "advances tweens correctly" do
+    Tsuku::Tweener.step(1000)
+    expect(target.x).to eq(10)
+  end
+
+  it "does not advance tweens when paused" do
+    Tsuku::Tweener.pause
+    Tsuku::Tweener.step(1000)
+    expect(target.x).to eq(1)
+  end
+
+  it "advances tweens when paused and resumed" do
+    Tsuku::Tweener.pause
+    Tsuku::Tweener.resume
+    Tsuku::Tweener.step(1000)
+    expect(target.x).to eq(10)
+  end
+
+  it "advances tweens correctly when earlier tween completes" do
+    Tsuku::Tweener.step(1000)
+    Tsuku::Tweener.step(1000)
+    expect(target.y).to eq(10)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tsuku
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - John Tuttle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-01 00:00:00.000000000 Z
+date: 2019-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,11 +84,14 @@ files:
 - lib/tsuku.rb
 - lib/tsuku/easing.rb
 - lib/tsuku/tween.rb
+- lib/tsuku/tweener.rb
 - lib/tsuku/version.rb
+- spec/easing_spec.rb
 - spec/spec_helper.rb
 - spec/support/mock_target.rb
 - spec/tsuku_spec.rb
 - spec/tween_spec.rb
+- spec/tweener_spec.rb
 - tsuku.gemspec
 homepage: https://github.com/jtuttle/tsuku
 licenses:
@@ -109,12 +112,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: A tweening library made with Ruby
 test_files:
+- spec/easing_spec.rb
 - spec/spec_helper.rb
 - spec/support/mock_target.rb
 - spec/tsuku_spec.rb
 - spec/tween_spec.rb
+- spec/tweener_spec.rb