gosu_android 0.0.1

data/lib/gosu_android/main-window.rb

@@ -0,0 +1,314 @@
+require 'gosu_android/requires'
+
+require 'gosu_android/graphics/graphics'
+require 'gosu_android/graphics/graphicsBase'
+require 'gosu_android/graphics/font'
+require 'gosu_android/input/input'
+require 'gosu_android/audio/audio'
+require 'gosu_android/physics/physicsManager'
+require 'gosu_android/timing'
+
+require 'singleton'
+require 'ruboto/util/toast'
+
+module Gosu
+
+  class AndroidInitializer
+    include Singleton
+    attr_reader :graphics, :surface_view
+    attr_reader :activity
+
+    def start activity
+      activity.toast 'Still loading please wait'
+      @activity = activity
+      @surface_view = GosuSurfaceView.new(@activity)
+      @graphics = Graphics.new(self)
+      @surface_view.renderer =  @graphics
+      @activity.content_view = @surface_view
+      activity.toast 'Still loading please wait'
+    end
+
+    def on_ready
+      @activity.on_ready
+    end
+  end
+
+  class GosuSurfaceView < android.opengl.GLSurfaceView
+
+    def atributes(window, input)
+      @window = window
+      @input = input
+    end
+
+    def onTouchEvent(event)
+      super
+      @input.feed_touch_event(event)
+      return true
+    end
+
+    def onKeyDown(keyCode, event)
+      super
+      @input.feed_key_event(keyCode, event)
+    end
+
+    def onKeyUp(keyCode, event)
+      super
+      @input.feed_key_event(keyCode, event)
+    end
+
+    def onWindowFocusChanged(has_focus)
+      super
+      if(@window)
+        @window.focus_changed(has_focus, self.get_width, self.get_height)
+      end
+    end
+  end
+
+
+  class Window
+    attr_accessor :caption
+    attr_accessor :mouse_x
+    attr_accessor :mouse_y
+    attr_accessor :text_input
+    attr_accessor :media_player
+    attr_reader :width, :height
+    attr_reader :fullscreen
+    attr_reader :update_interval
+    attr_reader :physics_manager
+    attr_reader :fonts_manager
+    attr_reader :activity
+
+    # update_interval:: Interval in milliseconds between two calls
+    # to the update member function. The default means the game will run
+    # at 60 FPS, which is ideal on standard 60 Hz TFT screens.
+    def initialize(width, height, fullscreen, update_interval=16.666666)
+      android_initializer = AndroidInitializer.instance
+      @fullscreen = fullscreen
+      @showing = false
+      @activity = android_initializer.activity
+      @display = @activity.getWindowManager.getDefaultDisplay
+      @width = width
+      @height= height
+      @update_interval = update_interval/1000.0
+      #@surface_view = GosuSurfaceView.new(@activity)
+      @surface_view = android_initializer.surface_view
+      @input = Input.new(@display, self)
+      @surface_view.atributes(self, @input)
+      #@graphics = Graphics.new(@width, @height, @fullscreen, self)
+      @graphics = android_initializer.graphics
+      @graphics.initialize_window(@width, @height, @fullscreen, self)
+      #@surface_view.renderer =  @graphics
+      @surface_view.set_render_mode(JavaImports::GLSurfaceView::RENDERMODE_WHEN_DIRTY)
+      @physics_manager = PhysicsManager.new self
+      @fonts_manager = FontsManager.new self
+      @media_player = nil
+    end
+
+    # Enters a modal loop where the Window is visible on screen and receives calls to draw, update etc.
+    def show
+      @showing = true
+      if @fullscreen
+        #Use full java path for Window, since there is a Gosu::Window
+        @activity.request_window_feature(JavaImports::Window::FEATURE_NO_TITLE)
+        @activity.get_window.set_flags(JavaImports::WindowManager::LayoutParams::FLAG_FULLSCREEN,
+            JavaImports::WindowManager::LayoutParams::FLAG_FULLSCREEN)
+        #@activity.content_view = @surface_view
+        @window = @activity.getWindow
+        #Replace position and size with gosu metrics
+      else
+        @window = @activity.getWindow
+        #Only the thread that created the view can change it, so setLayout
+        #and setTitle cannot be executed here
+        p = Proc.new do
+          @window.setLayout(@width, @height)
+          @activity.setTitle @caption
+        end
+        @activity.runOnUiThread(p)
+      end
+      @screen_width = @surface_view.get_width
+      @screen_height = @surface_view.get_height
+    end
+
+    def do_show
+      @start_time = Time.now
+      do_tick
+      #TODO gosu dark side
+      @end_time = Time.now
+      if (@start_time <= @end_time and (@end_time - @start_time) < @update_interval)
+          sleep(@update_interval - (@end_time - @start_time))
+      end
+    end
+
+    # Tells the window to end the current show loop as soon as possible.
+    def close
+      @showing = false
+    end
+
+    # Called every update_interval milliseconds while the window is being
+    # shown. Your application's main game logic goes here.
+    def update; end
+
+    # Called after every update and when the OS wants the window to
+    # repaint itself. Your application's rendering code goes here.
+    def draw; end
+
+    # Can be overriden to give the game a chance to say no to being redrawn.
+    # This is not a definitive answer. The operating system can still cause
+    # redraws for one reason or another.
+    #
+    # By default, the window is redrawn all the time (i.e. Window#needs_redraw?
+    # always returns true.)
+    def needs_redraw?; end
+
+    # Can be overriden to show the system cursor when necessary, e.g. in level
+    # editors or other situations where introducing a custom cursor is not
+    # desired.
+    def needs_cursor?; end
+
+    # Called before update when the user pressed a button while the
+    # window had the focus.
+    def button_down(id); end
+    # Same as buttonDown. Called then the user released a button.
+    def button_up(id); end
+
+    # Returns true if a button is currently pressed. Updated every tick.
+    def button_down?(id); end
+
+    # Called when the user started a touch on the screen
+    def touch_began(touch); end
+    # Called when the user continue a touch on the screen
+    def touch_moved(touch); end
+    # Called when the user finished a touch on the screen
+    def touch_ended(touch); end
+
+    # Called when and object collides with another object
+    def object_collided(x, y, object); end
+
+    # This object should be subject to the physics manager
+    def apply_physics(object)
+      @physics_manager.register_new_object(object)
+    end
+
+    # Stop applying physics to the given object
+    def stop_physics(object)
+      @physics_manager.delete_object(object)
+    end
+
+    # Draws a line from one point to another (last pixel exclusive).
+    # Note: OpenGL lines are not reliable at all and may have a missing pixel at the start
+    # or end point. Please only use this for debugging purposes. Otherwise, use a quad or
+    # image to simulate lines, or contribute a better draw_line to Gosu.
+    def draw_line(x1, y1, c1, x2, y2, c2, z=0, mode=AM_DEFAULT)
+      @graphics.draw_line(x1, y1, c1, x2, y2, c2, z, mode)
+    end
+
+    def draw_triangle(x1, y1, c1, x2, y2, c2, x3, y3, c3, z=0, mode=AM_DEFAULT)
+      @graphics.draw_triangle(x1, y1, c1, x2, y2, c2, x3, y3, c3, z, mode)
+    end
+
+    # Draws a rectangle (two triangles) with given corners and corresponding
+    # colors.
+    # The points can be in clockwise order, or in a Z shape.
+    def draw_quad(x1, y1, c1, x2, y2, c2, x3, y3, c3, x4, y4, c4, z=0, mode=AM_DEFAULT)
+      @graphics.draw_quad(x1, y1, c1, x2, y2, c2, x3, y3, c3, x4, y4, c4, z, mode)
+    end
+
+    # Flushes all drawing operations to OpenGL so that Z-ordering can start anew. This
+    # is useful when drawing several parts of code on top of each other that use conflicting
+    # z positions.
+    def flush; end
+
+    # For custom OpenGL calls. Executes the given block in a clean OpenGL environment.
+    # Use the ruby-opengl gem to access OpenGL function (if you manage to get it to work).
+    # IF no z position is given, it will execute the given block immediately, otherwise,
+    # the code will be scheduled to be called between Gosu drawing operations.
+    #
+    # Note: You cannot call Gosu rendering functions within this block, and you can only
+    # call the gl function in the call tree of Window#draw.
+    #
+    # See examples/OpenGLIntegration.rb for an example.
+    def gl(z=nil, &custom_gl_code); end
+
+    # Limits the drawing area to a given rectangle while evaluating the code inside of the block.
+    def clip_to(x, y, w, h, &rendering_code); end
+
+    # Returns a Gosu::Image that containes everything rendered within the given block. It can be
+    # used to optimize rendering of many static images, e.g. the map. There are still several
+    # restrictions that you will be informed about via exceptions.
+    #
+    # The returned Gosu::Image will have the width and height you pass as arguments, regardless
+    # of how the area you draw on. It is important to pass accurate values if you plan on using
+    # Gosu::Image#draw_as_quad or Gosu::Image#draw_rot with the result later.
+    #
+    # @return [Gosu::Image]
+    def record(width, height, &rendering_code); end
+
+    # Rotates everything drawn in the block around (around_x, around_y).
+    def rotate(angle, around_x=0, around_y=0, &rendering_code); end
+
+    # Scales everything drawn in the block by a factor.
+    def scale(factor_x, factor_y=factor_x, &rendering_code); end
+
+    # Scales everything drawn in the block by a factor for each dimension.
+    def scale(factor_x, factor_y, around_x, around_y, &rendering_code); end
+
+    # Moves everything drawn in the block by an offset in each dimension.
+    def translate(x, y, &rendering_code); end
+
+    # Applies a free-form matrix rotation to everything drawn in the block.
+    def transform(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15, &rendering_code); end
+
+    # Returns the character a button usually produces, or nil. To implement real text-input
+    # facilities, look at the TextInput class instead.
+    def self.button_id_to_char(id); end
+
+    # Returns the button that has to be pressed to produce the given character, or nil.
+    def self.char_to_button_id(char); end
+
+    # @deprecated Use Window#mouse_x= and Window#mouse_y= instead.
+    def set_mouse_position(x, y); end
+
+    def caption= value
+      @caption = value
+      if @showing and not @fullscreen
+        p = Proc.new do
+          @activity.setTitle @caption
+        end
+        @activity.runOnUiThread(p)
+      end
+    end
+
+    def do_tick
+      @input.update
+      self.update
+      @physics_manager.update
+      @graphics.begin(Color::BLACK)
+      self.draw
+      @graphics.end
+      @surface_view.request_render
+    end
+
+    def focus_changed has_focus, width, height
+      @screen_width = width
+      @screen_height = height
+      if @showing and @media_player != nil
+        if has_focus
+          @media_player.start
+        else
+          @media_player.pause
+        end
+     end
+    end
+
+    def show_soft_keyboard
+      context = @activity.getApplicationContext
+      imm = context.getSystemService(Context::INPUT_METHOD_SERVICE)
+      imm.toggleSoftInput(JavaImports::InputMethodManager::SHOW_FORCED,0)
+    end
+
+    def create_image(source, src_x, src_y, src_width, src_height, tileable)
+      @graphics.create_image(source, src_x, src_y, src_width, src_height, tileable)
+    end
+
+  end
+end

data/lib/gosu_android/math.rb

@@ -0,0 +1,21 @@
+module Gosu
+  
+  def self.offset_x(angle, radius)
+    Math::sin(angle / 180 * Math::PI) * radius
+  end
+  
+  def self.offset_y(angle, radius)
+    Math::cos(angle / 180 * Math::PI) * radius
+  end
+  
+  #Returns the square of the distance between two points.
+  def self.distance_sqr(x1, y1, x2, y2)
+    (x1 - x2)**2 + (y1 - y2)**2
+  end
+    
+  #Returns the distance between two points.
+  def self.distance(x1, y1, x2, y2)
+    Math::sqrt((x1 - x2)**2 + (y1 - y2)**2)
+  end    
+  
+end

data/lib/gosu_android/physics/physicsManager.rb

@@ -0,0 +1,57 @@
+require 'gosu_android/physics/physicsObject'
+
+module Gosu
+
+  class PhysicsManager
+    attr_accessor :gravity_x, :gravity_y
+    def initialize(window)
+      @window = window
+      @dt = @window.update_interval
+      @squares = []
+      @planes = []
+      @gravity_x = 0
+      @gravity_y = 98 #10 pixels are 1 meter
+    end
+
+    def register_new_object object
+      if object.class == Square
+        @squares.push object unless @squares.include? object
+      elsif object.class == Plane
+        @planes.push object unless @planes.include? object
+      end
+    end
+
+    def delete_object object
+      if object.class == Square
+        @squares.delete object
+      elsif  object.class == Plane
+        @planes.delete object
+      end
+    end
+
+    def update
+      #Gravity
+      @squares.each do |square|
+        if square.mass_inverted > 0
+          square.velocity[0] += @dt*@gravity_x
+          square.velocity[1] += @dt*@gravity_y
+        end
+      end
+
+     #Collision detection
+     @squares.each do |square|
+       @planes.each do |plane|
+         square.generate_contact plane
+       end
+     end
+
+     #Integrate
+      @squares.each do |square|
+        if square.mass_inverted > 0
+          square.integrate
+        end
+      end
+    end
+  end
+
+end

data/lib/gosu_android/physics/physicsObject.rb

@@ -0,0 +1,113 @@
+require 'gosu_android/graphics/image'
+
+module Gosu
+
+  def self.dot_product(l1, l2)
+    sum = 0
+    for i in 0...l1.size
+        sum += l1[i] * l2[i]
+    end
+    sum
+  end
+
+  def self.cross_product(l1,l2)
+    res = []
+    res.push( l1[1]*l2[2] - l1[2]*l2[1] );
+    res.push( l1[2]*l2[0] - l1[0]*l2[2] );
+    res.push( l1[0]*l2[1] - l1[1]*l2[0] );
+    d = res.max
+    if(d == 0)
+      d = res.min
+      res[0] = res[0]/-d
+      res[1] = res[1]/-d
+    else
+      res[0] = res[0]/d
+      res[1] = res[1]/d
+    end
+    res
+  end
+
+  class Square
+    attr_accessor :velocity
+    attr_reader :position, :center
+    attr_reader :mass_inverted, :restitution
+    def initialize(window, file_name, x, y, z, size, mass_inverted,
+      velocity_x = 0, velocity_y = 0, restitution = 1, tileable = false)
+      @window = window
+      @position = [x,y]
+      @size = size / 2
+      @center = [@position[0] + @size, @position[1] + @size]
+      @z = z
+      @restitution = restitution
+      @velocity = [velocity_x, velocity_y]
+      @mass_inverted = mass_inverted
+      @image = Gosu::Image.new(@window, file_name , tileable)
+      @dt = @window.update_interval
+    end
+
+    def integrate
+      @position[0] += @velocity[0]*@dt
+      @position[1] += @velocity[1]*@dt
+      @center = [@position[0] + @size, @position[1] + @size]
+    end
+
+    def generate_contact other_object
+      if other_object.class == Square
+      elsif other_object.class == Plane
+        if @center[0] - @size < other_object.top_limit[0] and other_object.bottom_limit[0] < @center[0] + @size and
+          @center[1] - @size < other_object.bottom_limit[1] and other_object.top_limit[1] < @center[1] + @size
+          #Calculate new velocity, after the hit
+          if other_object.type == :vertical
+            @velocity[0] -= (1 + @restitution) * @velocity[0]
+          else
+            @velocity[1] -= (1 + @restitution) * @velocity[1]
+          end
+          #Call window event
+          @window.object_collided( @position[0], @position[1], other_object )
+        end
+      end
+    end
+
+    def draw
+      @image.draw(@position[0], @position[1], @z)
+    end
+
+  end
+
+  # Bottom ----- Top
+  #
+  #  Top
+  #   |
+  #   |
+  #   |
+  # Bottom
+  class Plane
+    attr_accessor :bottom_limit, :top_limit
+    attr_reader :type
+    def initialize(window, file_name, p0, p1, z)
+      @window = window
+      @image = Gosu::Image.new(@window, file_name)
+      @z = z
+      @top_limit = Array.new p0
+      @bottom_limit = Array.new p1
+
+      if(@bottom_limit[0] > @top_limit[0] or @bottom_limit[1] < @top_limit[1])
+        @top_limit, @bottom_limit = @bottom_limit, @top_limit
+      end
+
+      if @bottom_limit[0] == @top_limit[0]
+        @type = :vertical
+      elsif @bottom_limit[1] == @top_limit[1]
+        @type = :horizontal
+      else
+        raise "Planes can only be horizontal or vertical"
+      end
+
+    end
+
+    def draw(x,y,z = @z)
+      @image.draw(x,y,z)
+    end
+
+  end
+end