sdl2_ffi 0.0.6 → 0.0.7

data/spec/functional/lazy_foo_tutorial/lazy_foo_14_regulating_frame_rate_spec.rb

@@ -0,0 +1,67 @@
+require_relative 'lazy_foo_helper'
+require_relative 'timer'
+#ORIGINAL: http://lazyfoo.net/SDL_tutorials/lesson14/index.php
+# Adapted for Ruby & SDL 2.0 as functional test by BadQuanta
+
+require 'bad_sdl/application'
+require 'bad_sdl/engine/block_engine'
+require 'sdl2/ttf'
+
+FRAMES_PER_SECOND = 20
+
+describe "LazyFoo.net: Lesson 14: Advanced Timers" do
+  before do
+    SDL2.init!(:EVERYTHING)
+    @app = BadSdl::Application.new
+    @frame = 0
+    @cap = true
+    @fps = Timer.new
+
+    TTF::init!
+    @font = TTF::Font.open(FONT_PATH, 32)
+    @message = @font.render_text_blended("Testing Frame Rate")
+
+    @app.before_loop do
+      puts "before loop"
+      @fps.start()
+    end
+
+    @app.on({type: :KEYDOWN, key: {keysym: {sym: :RETURN}}}) do |event|
+      print "CAP IS: "
+      @cap = !@cap
+      puts @cap ? "ON" : "OFF"
+    end
+
+    @app.after_loop do
+      puts "after loop"
+      @frame += 1
+      if @cap and (@fps.get_ticks() < 1000 / FRAMES_PER_SECOND)
+        SDL2::delay((1000 / FRAMES_PER_SECOND) - @fps.get_ticks() )
+      end
+    end
+
+    @app.painter do |surface|
+      puts "painter"
+      surface.fill_rect(surface.rect, [0,0,0])
+
+      @message.blit_out(surface, {
+        x: (surface.w - @message.w) / 2,
+        y: ((surface.h + @message.h * 2) / FRAMES_PER_SECOND) * ( @frame % FRAMES_PER_SECOND) - @message.h
+      })
+
+      @app.window().update_surface
+      true
+    end
+
+  end
+
+  after do
+    @app.quit
+    SDL2.quit
+  end
+
+  it "works" do
+    skip "Don't know how to test this"
+    @app.loop nil #, #delay: 100
+  end
+end

data/spec/functional/lazy_foo_tutorial/lazy_foo_15_calculating_frame_rate_spec.rb

@@ -0,0 +1,48 @@
+require_relative 'lazy_foo_helper'
+require_relative 'timer'
+#ORIGINAL: http://lazyfoo.net/SDL_tutorials/lesson14/index.php
+# Adapted for Ruby & SDL 2.0 as functional test by BadQuanta
+
+require 'bad_sdl/application'
+require 'bad_sdl/engine/block_engine'
+require 'sdl2/ttf'
+
+describe "LazyFoo.net: Lesson 15: Advanced Timers" do
+  
+  before do
+    SDL2.init(:EVERYTHING)
+    @app = BadSdl::Application.new(title: subject)
+    @frame = 0
+    @fps = Timer.new
+    @update = Timer.new
+    @update.start
+    @fps.start
+    
+    @image = Image.load!(img_path('background.png'))
+    
+    @app.painter do |surface|
+      surface.fill_rect(surface.rect, [0, 0, 0])
+      @image.blit_out(surface)
+      true      
+    end
+    
+    @app.after_loop do 
+      @frame += 1
+      if @update.get_ticks() > 1000
+        
+        fps = @frame./(@fps.get_ticks()./(1000.0))
+        @app.window.title = "Average Frames Per Second: #{fps}"
+      end
+    end
+  end
+  
+  after do
+    @app.quit
+    SDL2.quit
+  end
+  
+  it "works" do
+    @app.loop(1)
+    skip "don't know how to test this"
+  end
+end

data/spec/functional/lazy_foo_tutorial/lazy_foo_16_motion_spec.rb

@@ -0,0 +1,95 @@
+require_relative 'lazy_foo_helper'
+require_relative 'timer'
+#ORIGINAL: http://lazyfoo.net/SDL_tutorials/lesson16/index.php
+# Adapted for Ruby & SDL 2.0 as functional test by BadQuanta
+
+require 'bad_sdl/application'
+require 'bad_sdl/engine/block_engine'
+require 'sdl2/ttf'
+
+describe "LazyFoo.net: Lesson 16: Motion" do
+
+  class Dot
+
+    def initialize(opts)
+      @x = opts[:x] || 0
+      @y = opts[:y] || 0
+      @xVel = opts[:xVel] || 0
+      @yVel = opts[:yVel] || 0
+      @sprite = opts[:sprite] || SDL2::Image.load!(img_path('foo.jpg'))
+    end
+
+    def handle_input(event)
+      case event.key.keysym.sym
+        when :UP then @yVel -= @dot.h / 2
+        when :DOWN then @yVel += @dot.h / 2
+        when :LEFT then @xVel -= @dot.w / 2
+        when :RIGHT then @xVel += @dot.w / 2
+      end
+    end
+
+    def accelerate(x,y)
+      @xVel += x
+      @yVel += y
+      puts "New Vector: #{@xVel},#{@yVel}"
+    end
+
+    def move
+      @x += @xVel
+      @y += @yVel
+    end
+
+    def show(surface)
+      @sprite.blit_out(surface, [@x,@y])
+
+    end
+  end#class Dot
+
+  before do
+    SDL2.init!(:EVERYTHING)
+    @app = BadSdl::Application.new title: subject
+    @dot = Dot.new(
+    x: @app.window.surface.w / 2,
+    y: @app.window.surface.h / 2,
+    sprite: @app.window.surface.convert(SDL2::Image.load!(img_path('foo.jpg')))
+    )
+
+    @app.on(key: :KEYUP, key: {keysym: {sym: :UP}}) do
+      @dot.accelerate(0,-1)
+    end
+
+    @app.on(key: :KEYUP, key: {keysym: {sym: :DOWN}}) do
+      @dot.accelerate(0,1)
+    end
+
+    @app.on(key: :KEYUP, key: {keysym: {sym: :LEFT}}) do
+      @dot.accelerate(-1,0)
+    end
+
+    @app.on(key: :KEYUP, key: {keysym: {sym: :RIGHT}}) do
+      @dot.accelerate(1,0)
+    end
+
+    @app.after_loop do
+      @dot.move
+      delay(10)
+    end
+
+    @app.painter do |surface|
+      surface.fill_rect(surface.rect, [0,0,0])
+      @dot.show(surface)
+      true
+    end
+
+  end
+  
+  after do 
+    @app.quit
+    SDL2.quit
+  end
+  
+  it "works" do
+    skip 'refine later'
+    @app.loop()
+  end
+end

data/spec/functional/lazy_foo_tutorial/lazy_foo_helper.rb

@@ -3,4 +3,6 @@ require_relative '../../spec_helper'
 require 'sdl2'
 require 'sdl2/image'
 
-include SDL2
+include SDL2
+
+FONT_PATH = fixture('fonts/GaroaHackerClubeBold.otf')

data/spec/functional/lazy_foo_tutorial/timer.rb

@@ -0,0 +1,55 @@
+require 'sdl2'
+class Timer
+
+  def initialize
+    @start_ticks = 0
+    @paused_ticks = 0
+    @paused = false
+    @started = false
+  end
+
+  def start
+    @started = true
+    @paused = false
+    @start_ticks = SDL2::get_ticks()
+  end
+
+  def stop
+    @started = false
+    @paused = false
+  end
+
+  def pause
+    if started? and not paused?
+      @paused = true
+      @paused_ticks = SDL2::get_ticks() - @start_ticks
+    end
+  end
+
+  def unpause
+    if paused?
+      @paused = false
+      @start_ticks = SDL2::get_ticks() - @paused_ticks
+      @paused_ticks = 0
+    end
+  end
+
+  def get_ticks
+    if started?
+      if paused?
+        return @paused_ticks
+      else
+        return SDL2::get_ticks() - @start_ticks
+      end
+    end
+    return 0
+  end
+
+  def paused?
+    @paused
+  end
+
+  def started?
+    @started
+  end
+end

data/spec/lib/bad_sdl/application_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+
+require 'bad_sdl/application'
+
+
+describe BadSdl::Application do
+  before :each do
+    SDL2.init(:EVERYTHING)
+    @app = BadSdl::Application.new title: example.metadata[:example_group][:full_description]    
+  end
+  
+  after :each do
+    @app.quit()
+    SDL2.quit
+  end
+  
+
+  
+  
+  
+  
+end

data/spec/{unit → lib}/sdl2/color_spec.rb

@@ -3,11 +3,15 @@ require_relative '../unit_helper'
 describe SDL2::Color do
   before :each do
     SDL2.init!(:EVERYTHING)
-    @window = SDL2::Window.create(subject.to_s, :CENTERED, :CENTERED, 100, 100)
+    @window = SDL2::Window.create(title: subject.to_s, width: 100, height: 100)
     @screen = @window.surface
     @color = SDL2::Color.new
   end
   
+  after :each do
+    SDL2.quit
+  end
+  
   it 'looks RED when it should' do
     @color.set(255,0,0,255)
   end

data/spec/lib/sdl2/display_spec.rb

@@ -0,0 +1,6 @@
+require_relative '../../spec_helper'
+
+describe SDL2::Display do
+ 
+  
+end

data/spec/lib/sdl2/event_spec.rb

@@ -0,0 +1,102 @@
+require_relative '../../spec_helper'
+
+describe SDL2::Event do
+  before :each do
+    SDL2.init!(:VIDEO)
+    SDL2::Debug.enable(SDL2::Event)
+  end
+  
+  
+  it 'should provide event states' do
+    SDL2::Event.should respond_to(:state)
+    SDL2::Event.state(:KEYDOWN).should == true
+    SDL2::Event.state(:KEYDOWN, :IGNORE).should == true # Because it was true
+    SDL2::Event.state(:KEYDOWN).should == false # Because now it's disabled.
+    SDL2::Event.state(:KEYDOWN, :ENABLE).should == false #getting it?
+    SDL2::Event.state(:KEYDOWN).should == true
+  end
+  
+  it 'should be able to filter events' do
+    SDL2::Event.should respond_to(:filter)
+    SDL2::Event.push(SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYDOWN, keysym: {sym: :A}} )))
+    count = 0
+    SDL2::Event.filter do |data, event|
+      count += 1      
+    end
+    count.should == 1
+  end
+  
+  it 'should be able to flush an event type' do
+    SDL2::Event.push SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYDOWN, keysym: {sym: :A}} ))
+    SDL2::Event.push SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYUP, keysym: {sym: :B}} ))
+    SDL2::Event.has?(:KEYDOWN).should == true
+    SDL2::Event.has?(:KEYUP).should == true
+    SDL2::Event.flush(:KEYDOWN)
+    SDL2::Event.has?(:KEYDOWN).should == false
+    SDL2::Event.has?(:KEYUP).should == true
+  end
+  
+  it 'should be able to return the event filter' do
+    skip 'unsure how to test right now'
+    my_filter = lambda do |data, event|
+      0 if event.type == :KEYDOWN
+      1
+    end
+        
+    SDL2::Event.filter.should == false
+    SDL2::Event.filter= my_filter
+    SDL2::Event.filter.should == my_filter
+  end
+  
+  it 'should be able to peep events' do
+    events = [
+    SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYDOWN,  keysym: {sym: :A}} )),
+    SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYUP,    keysym: {sym: :B}} )),
+    SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYDOWN,  keysym: {sym: :C}} )),
+    SDL2::Event.cast(SDL2::Event::Keyboard.cast({type: :KEYUP,    keysym: {sym: :D}} )),
+    ]
+    events.each do |event|
+      SDL2::Event.push(event)
+    end
+    SDL2::Event.should respond_to(:peep)
+    retrieved = SDL2::Event.peep(nil, 3, :PEEK, :FIRSTEVENT, :LASTEVENT)
+    # The SDL2::Events won't match since they are different pointers,
+    # but hey, if we pull the values out we can see that they match just fine
+    per = lambda do |e| 
+      [e.type, e.key.keysym.sym]
+    end
+    retrieved.map(&per).should == events.map(&per).first(3)
+  end
+  
+  it 'should be able to pump events' do
+    SDL2::Event.should respond_to(:pump)
+    # Count the number of events pumped.
+    count = 0
+    # Setup a filter to count the events pumped.
+    SDL2::Event.filter= lambda do |data, event|
+      count += 1
+    end
+    # Create some events and push
+    [
+        SDL2::Event::Keyboard.cast({type: :KEYDOWN,  keysym: {sym: :A}} ).to_event,
+        SDL2::Event::Keyboard.cast({type: :KEYUP,    keysym: {sym: :B}} ).to_event,
+        SDL2::Event::Keyboard.cast({type: :KEYDOWN,  keysym: {sym: :C}} ).to_event,
+        SDL2::Event::Keyboard.cast({type: :KEYUP,    keysym: {sym: :D}} ).to_event,
+    ].each {|e|SDL2::Event.push(e)}
+    # Test the routine:
+    SDL2::Event.pump
+    count.should == 4 
+  end
+  
+  it 'should indicate if an SDL::Event::Quit is in the Que' do
+    SDL2::Event.should respond_to(:quit_requested?)
+    #
+    SDL2::Event.quit_requested?.should == false
+    SDL2::Event.push SDL2::Event::Quit.cast({type: :QUIT}).to_event
+    SDL2::Event.quit_requested?.should == true
+  end
+ 
+  after :each do
+    SDL2.quit
+  end
+end

data/spec/lib/sdl2/events_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../../spec_helper'
+
+describe SDL2 do
+  it 'should have the SDL_events.h API' do
+    [
+      :event_state?,
+
+    ].each do |function|
+      SDL2.should respond_to(function)  
+    end
+  end
+end

data/spec/lib/sdl2/joystick_spec.rb

@@ -0,0 +1,130 @@
+require_relative '../../spec_helper'
+
+describe SDL2 do
+  it 'should have the joystick API' do
+    # Joystick API
+    [
+      :joystick_close,
+      :joystick_event_state,
+      :joystick_event_state?,
+      :joystick_get_attached,
+      :joystick_get_attached?,
+      :num_joysticks,
+      :num_joysticks!,
+      :joystick_update,
+      :joystick_open,
+      :joystick_open!,
+      :joystick_num_hats,
+      :joystick_num_hats!,
+      :joystick_num_buttons,
+      :joystick_num_buttons!,
+      :joystick_num_balls,
+      :joystick_num_balls!,
+      :joystick_num_axes,
+      :joystick_num_axes!,
+      :joystick_name_for_index,
+      :joystick_name_for_index!,
+      :joystick_name,
+      :joystick_instance_id,
+      :joystick_instance_id!,
+      :joystick_get_hat,
+      # TODO: Implement Joystick GUID helpers?
+      :joystick_get_guid_string,
+      :joystick_get_guid_from_string,
+      :joystick_get_guid,
+      :joystick_get_device_guid,
+      :joystick_get_button,
+      :joystick_get_ball,
+      :joystick_get_axis,
+      :joystick_get_axis!,
+    ].each do |method|
+      SDL2.should respond_to(method)
+    end
+  end
+  
+  describe SDL2::Joystick do
+    before :each do
+      SDL2.init(:JOYSTICK)
+      joy_count = SDL2.num_joysticks 
+      skip "There are no Joysticks" if joy_count < 1
+      
+      @joysticks = joy_count.times.map {|idx| SDL2::Joystick.open(idx)}
+    end
+    
+    
+    it 'should have a name' do
+      @joysticks.each{|j|j.name.should be_a(String)}
+    end 
+    
+    it 'should have an event state' do
+      @joysticks.each do |joystick|
+        joystick.event_state(:IGNORE)
+        joystick.event_state.should == false
+        joystick.event_state(:ENABLE)
+        joystick.event_state.should == true
+      end
+    end
+    
+    describe SDL2::Joystick::Buttons do            
+      it 'should return a state for each button on each joystick' do
+        @joysticks.delete_if{|js|js.buttons.count < 1}
+        skip "no buttons" if @joysticks.empty?
+        @joysticks.each do |joystick|          
+          joystick.buttons.each do |button|            
+            button.should be_a(Integer)
+            button.should >= 0
+            button.should <= 1
+          end
+        end
+      end
+    end
+    
+    describe SDL2::Joystick::Axes do
+      it 'should return an integer for each axis' do
+        @joysticks.delete_if{|js|js.axes.count < 1}
+        skip "no axes" if @joysticks.empty?        
+        @joysticks.each do |joystick|
+          joystick.axes.each do |axis|
+            axis.should be_a(Integer)
+            axis.should >= -32768
+            axis.should <= 32767
+          end
+        end
+      end
+    end
+    
+    describe SDL2::Joystick::Balls do
+      it 'should return a delta x, delta y pair' do
+        @joysticks.delete_if {|js|js.balls.count < 1}
+        skip "no balls" if @joysticks.empty?
+        @joysticks.each do |joystick|
+          joystick.balls.each do |ball|
+            ball.should be_a(Array)
+            ball.count.should == 2
+            ball.each do |value|
+              value.should be_a(Integer)            
+            end
+          end          
+        end
+      end
+    end
+    
+    describe SDL2::Joystick::Hats do
+      it 'should return a valid SDL2::HAT value' do
+        @joysticks.delete_if{|js|js.hats.count < 1}
+        skip 'no hats' if @joysticks.empty?
+        @joysticks.each do |joystick|
+          joystick.hats.each do |hat|
+            hat.should be_a(Integer)
+            hat.should >= 0
+            hat.should <= 12
+          end
+        end
+      end
+    end
+
+    after :each do
+      SDL2.quit
+    end
+  end
+end