xibe 0.0.1

data/LICENSE

@@ -0,0 +1,3 @@
+== Xibe
+
+Put appropriate LICENSE for your project here.

data/README

@@ -0,0 +1,3 @@
+== Xibe
+
+You should document your project here.

data/Rakefile

@@ -0,0 +1,48 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'xibe'
+  s.version = '0.0.1'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Developer Game'
+  s.description = s.summary
+  s.author = 'Michel Brito'
+  s.email = 'micheljunio@gmail.com'
+  s.homepage = "http://codesheep.com/xibe/"
+  s.rubyforge_project = 'xibe'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+  #s.add_dependency("rubysdl", ">= 1.3.0")
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "Xibe Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/xibe.rb

@@ -0,0 +1,699 @@
+require 'rubygems'
+require 'sdl'
+
+class Fixnum
+  def seconds
+    self * 1000
+  end
+end
+
+class Float
+  def seconds
+    self * 1000
+  end
+end
+
+module Xibe
+  module Event
+    class Keyboard
+      def self.down?
+        if $keydown.nil? == false && $keydown == sym(self.name)
+          $keydown = nil
+          return true
+        end
+      end
+
+      def self.up?
+        if $keyup.nil? == false && $keyup == sym(self.name)
+          $keyup = nil
+          return true
+        end
+      end
+
+      def self.press?
+        k = sym(self.name)
+        SDL::Key.press?(k)
+      end
+
+      def self.sym(key)
+        k = key.gsub("Xibe::Event::K_", "")
+        eval "SDL::Key::" + k
+      end
+    end
+
+    def keydown?
+      if $any_keydown
+        $any_keydown = false
+        return true
+      end
+    end
+
+    def keyup?
+      unless $any_keyup.nil?
+        $any_keyup = nil
+        return true
+      end
+    end
+
+    class K_BACKSPACE < Keyboard; end
+    class K_TAB < Keyboard; end
+    class K_CLEAR < Keyboard; end
+    class K_RETURN < Keyboard; end
+    class K_PAUSE < Keyboard; end
+    class K_ESCAPE < Keyboard; end
+    class K_SPACE < Keyboard; end
+    class K_EXCLAIM < Keyboard; end
+    class K_QUOTEDBL < Keyboard; end
+    class K_HASH < Keyboard; end
+    class K_DOLLAR < Keyboard; end
+    class K_AMPERSAND < Keyboard; end
+    class K_QUOTE < Keyboard; end
+    class K_LEFTPAREN < Keyboard; end
+    class K_RIGHTPAREN < Keyboard; end
+    class K_ASTERISK < Keyboard; end
+    class K_PLUS < Keyboard; end
+    class K_COMMA < Keyboard; end
+    class K_MINUS < Keyboard; end
+    class K_PERIOD < Keyboard; end
+    class K_SLASH < Keyboard; end
+    class K_K0 < Keyboard; end
+    class K_K1 < Keyboard; end
+    class K_K2 < Keyboard; end
+    class K_K3 < Keyboard; end
+    class K_K4 < Keyboard; end
+    class K_K5 < Keyboard; end
+    class K_K6 < Keyboard; end
+    class K_K7 < Keyboard; end
+    class K_K8 < Keyboard; end
+    class K_K9 < Keyboard; end
+    class K_COLON < Keyboard; end
+    class K_SEMICOLON < Keyboard; end
+    class K_LESS < Keyboard; end
+    class K_EQUALS < Keyboard; end
+    class K_GREATER < Keyboard; end
+    class K_QUESTION < Keyboard; end
+    class K_AT < Keyboard; end
+    class K_LEFTBRACKET < Keyboard; end
+    class K_BACKSLASH < Keyboard; end
+    class K_RIGHTBRACKET < Keyboard; end
+    class K_CARET < Keyboard; end
+    class K_UNDERSCORE < Keyboard; end
+    class K_BACKQUOTE < Keyboard; end
+    class K_A < Keyboard; end
+    class K_B < Keyboard; end
+    class K_C < Keyboard; end
+    class K_D < Keyboard; end
+    class K_E < Keyboard; end
+    class K_F < Keyboard; end
+    class K_G < Keyboard; end
+    class K_H < Keyboard; end
+    class K_I < Keyboard; end
+    class K_J < Keyboard; end
+    class K_K < Keyboard; end
+    class K_L < Keyboard; end
+    class K_M < Keyboard; end
+    class K_N < Keyboard; end
+    class K_O < Keyboard; end
+    class K_P < Keyboard; end
+    class K_Q < Keyboard; end
+    class K_R < Keyboard; end
+    class K_S < Keyboard; end
+    class K_T < Keyboard; end
+    class K_U < Keyboard; end
+    class K_V < Keyboard; end
+    class K_W < Keyboard; end
+    class K_X < Keyboard; end
+    class K_Y < Keyboard; end
+    class K_Z < Keyboard; end
+    class K_DELETE < Keyboard; end
+    class K_KP0 < Keyboard; end
+    class K_KP1 < Keyboard; end
+    class K_KP2 < Keyboard; end
+    class K_KP3 < Keyboard; end
+    class K_KP4 < Keyboard; end
+    class K_KP5 < Keyboard; end
+    class K_KP6 < Keyboard; end
+    class K_KP7 < Keyboard; end
+    class K_KP8 < Keyboard; end
+    class K_KP9 < Keyboard; end
+    class K_KP_PERIOD < Keyboard; end
+    class K_KP_DIVIDE < Keyboard; end
+    class K_KP_MULTIPLY < Keyboard; end
+    class K_KP_MINUS < Keyboard; end
+    class K_KP_PLUS < Keyboard; end
+    class K_KP_ENTER < Keyboard; end
+    class K_KP_EQUALS < Keyboard; end
+    class K_UP < Keyboard; end
+    class K_DOWN < Keyboard; end
+    class K_RIGHT < Keyboard; end
+    class K_LEFT < Keyboard; end
+    class K_INSERT < Keyboard; end
+    class K_HOME < Keyboard; end
+    class K_END < Keyboard; end
+    class K_PAGEUP < Keyboard; end
+    class K_PAGEDOWN < Keyboard; end
+    class K_F1 < Keyboard; end
+    class K_F2 < Keyboard; end
+    class K_F3 < Keyboard; end
+    class K_F4 < Keyboard; end
+    class K_F5 < Keyboard; end
+    class K_F6 < Keyboard; end
+    class K_F7 < Keyboard; end
+    class K_F8 < Keyboard; end
+    class K_F9 < Keyboard; end
+    class K_F10 < Keyboard; end
+    class K_F11 < Keyboard; end
+    class K_F12 < Keyboard; end
+    class K_F13 < Keyboard; end
+    class K_F14 < Keyboard; end
+    class K_F15 < Keyboard; end
+    class K_NUMLOCK < Keyboard; end
+    class K_CAPSLOCK < Keyboard; end
+    class K_SCROLLOCK < Keyboard; end
+    class K_RSHIFT < Keyboard; end
+    class K_LSHIFT < Keyboard; end
+    class K_RCTRL < Keyboard; end
+    class K_LCTRL < Keyboard; end
+    class K_RALT < Keyboard; end
+    class K_LALT < Keyboard; end
+    class K_RMETA < Keyboard; end
+    class K_LMETA < Keyboard; end
+    class K_LSUPER < Keyboard; end
+    class K_RSUPER < Keyboard; end
+    class K_MODE < Keyboard; end
+    class K_HELP < Keyboard; end
+    class K_PRINT < Keyboard; end
+    class K_SYSREQ < Keyboard; end
+    class K_BREAK < Keyboard; end
+    class K_MENU < Keyboard; end
+    class K_POWER < Keyboard; end
+    class K_EURO < Keyboard; end
+
+    class Joystick
+      def self.press?
+        return false if $joystick.nil?
+        result = false
+        b = self.name.gsub "Xibe::Event::J_", ""
+        if b == "UP"
+          result = true if $joystick.axis(1) == 0
+        elsif b == "DOWN"
+          result = true if $joystick.axis(1) == 255
+        elsif b == "LEFT"
+          result = true if $joystick.axis(0) == 0
+        elsif b == "RIGHT"
+          result = true if $joystick.axis(0) == 255
+        else
+          b = b.delete "B"
+          result = $joystick.button(b.to_i)
+        end
+        result
+      end
+
+      def self.direction_press?
+        return false if $joystick.nil?
+        $joystick.axis(0) != 127 || $joystick.axis(1) != 127
+      end
+    end
+
+    class J_B0 < Joystick; end
+    class J_B1 < Joystick; end
+    class J_B2 < Joystick; end
+    class J_B3 < Joystick; end
+    class J_B4 < Joystick; end
+    class J_B5 < Joystick; end
+    class J_B6 < Joystick; end
+    class J_B7 < Joystick; end
+    class J_B8 < Joystick; end
+    class J_B9 < Joystick; end
+    class J_B10 < Joystick; end
+    class J_UP < Joystick; end
+    class J_RIGHT < Joystick; end
+    class J_DOWN < Joystick; end
+    class J_LEFT < Joystick; end
+
+
+    QUIT = SDL::Event2::Quit
+  end
+
+  $bg_cmap = []
+  $collide_box = []
+
+  @@window = nil
+  class Application
+    attr_accessor :x, :y, :width, :height, :fps, :scene
+    #width, height: window size; fullscreen: fullscreen mode; fps: frames per seconds
+    def initialize(width, height, fullscreen = false, fps=30)
+      @width = width
+      @height = height
+      @fullscreen = fullscreen
+      @fps = fps
+      @@window = self
+      
+      SDL.init(SDL::INIT_EVERYTHING)
+
+      if SDL::Joystick.num > 0
+        $joystick = SDL::Joystick.open(0)
+      end
+
+      #SDL::Mixer.open(22050)
+      SDL::Mouse.hide
+      mode = @fullscreen == true ? SDL::FULLSCREEN|SDL::HWSURFACE : SDL::HWSURFACE
+      @screen = SDL::setVideoMode @width, @height, 16, mode
+    end
+
+    #Sets the window title
+    def title=(title)
+      SDL::WM.set_caption title, ''
+    end
+
+    #Sets the window icon
+    def icon=(filename)
+      SDL::WM.icon = SDL::Surface.load filename
+    end
+
+    #Run application
+    def run
+      timer = Timer.new
+      loop do
+        timer.start
+        SDL::Key.scan
+        while event = SDL::Event2.poll
+          case event
+          when SDL::Event2::Quit
+            exit
+          when SDL::Event2::KeyDown
+            $keydown = event.sym
+            $any_keydown = true
+          when SDL::Event2::KeyUp
+            $keyup = event.sym
+            $any_keyup = true
+          end
+        end
+
+        input
+        update
+        draw
+        @screen.flip
+        SDL.delay( (1000 / @fps) - timer.ticks ) if timer.ticks < 1000 / @fps
+      end
+    end
+
+    def input
+      scene_input unless @scene.nil?
+    end
+
+    def update
+      scene_update unless @scene.nil?
+    end
+
+    def draw
+      scene_draw unless @scene.nil?
+    end
+
+    #Sets the scene to display
+    def display(scene)
+      @scene = scene
+      @screen.set_clip_rect(0,0,@scene.width,@scene.height)
+    end
+    
+    private
+    def scene_input
+      @scene.input
+    end
+
+    def scene_update
+      @scene.update
+    end
+
+    def scene_draw
+      @screen.fill_rect(0,0,@width,@height,@scene.fill)
+      @scene.draw
+    end
+  end
+
+  class Layer
+    attr_accessor :x, :y, :width, :height, :z, :visible
+    def initialize
+      @x = 0
+      @y = 0
+      @width = 0
+      @height = 0
+      @z = 0
+      @visible = true
+    end
+    
+    def show
+      @visible = true
+    end
+
+    def hide
+      @visible = false
+    end
+
+    #Returns the top position
+    def top
+      @y
+    end
+
+    #Returns the right position
+    def right
+      @x + @width
+    end
+
+    #Returns the bottom position
+    def bottom
+      @y + @height
+    end
+
+    #Returns the left position
+    def left
+      @x
+    end
+
+    #Sets X and Y position
+    def pos(x, y)
+      @x = x
+      @y = y
+    end
+  end
+
+  class Scene
+    include Event
+    attr_accessor :fill, :camera
+    attr_reader :width, :height
+    def initialize(width, height,fill = 0x00)
+      @width = width
+      @height = height
+      @fill = fill
+      @camera = Layer.new
+      @camera.width = @@window.width
+      @camera.height = @@window.height
+      @objects = []
+    end
+
+    def finalize
+
+    end
+
+    #Load map from file
+    def load_map(filename)
+      lines = File.open(filename).readlines.join
+      map = eval(lines)
+      map[:tilesets].each do |tileset|
+        self.instance_variable_set("@#{tileset[:name]}", Image.to_tiles(tileset[:filename], tileset[:width], tileset[:height], tileset[:transparent], tileset[:margin]))
+      end
+
+      map[:tilemaps].each do |tilemap|
+        tiles =  self.instance_variable_get("@#{tilemap[:tileset]}")
+        tlmap = self.instance_variable_set("@#{tilemap[:name]}", Tilemap.new(tiles, tilemap[:obstacle]))
+        tlmap.x = tilemap[:x]
+        tlmap.y = tilemap[:y]
+        tlmap.z = tilemap[:z]
+        tlmap.load_map tilemap[:map], tilemap[:width], tilemap[:height]
+        add(tlmap)
+      end
+    end
+    
+    #Sets the scene to display
+    def display(scene)
+      finalize
+      @@window.scene = scene
+      SDL.get_video_surface.set_clip_rect(0,0,@width,@height)
+    end
+
+    def update
+      
+    end
+
+    #Add the object to scene
+    def add(object)
+      @objects << object
+      @objects = @objects.uniq
+    end
+
+    #Delete the object from scene
+    def delete(object)
+      @objects.delete(object)
+    end
+
+    #Keyboard, Joystick or Mouse
+    def input
+      
+    end
+
+    #Center camera relative to object
+    def center_camera_relative_to(object)
+      @camera.x = ( object.x + object.width / 2 ) - @camera.width / 2;
+      @camera.y = ( object.y + object.height / 2 ) - @camera.height / 2;
+
+      if @camera.left < 0
+        @camera.x = 0
+      end
+
+      if @camera.top < 0
+        @camera.y = 0
+      end
+
+      if @camera.right > @width
+        @camera.x = @width - @camera.width
+      end
+
+      if @camera.bottom > @height
+        @camera.y = @height - @camera.height
+      end
+    end
+
+    #Draw scene
+    def draw
+      objs = @objects.sort_by { |obj| [obj.z] }
+      objs.each do |obj|
+        obj.draw
+      end
+    end
+  end
+
+  class Image < Layer
+    attr_reader :filename
+    attr_accessor :src_x, :src_y
+    def initialize(filename, transparent=false)
+      super()
+      @filename = filename
+      @image = Image.create(@filename, transparent)
+      @width = @image.w
+      @height = @image.h
+      @src_x = 0
+      @src_y = 0
+    end
+
+    #Create a image
+    def self.create(filename, transparent=false)
+      img = SDL::Surface.load(filename)
+      color_key = img.get_pixel(0,0)
+      img.set_color_key(SDL::SRCCOLORKEY ,color_key) if transparent == true
+      img.display_format
+    end
+
+    #Create a tiles from a image file
+    def self.to_tiles(filename, width, height, transparent = false, margin = 0)
+      img = create(filename, false)
+      color_key = img.get_pixel(0,0)
+      t_width = (img.w-margin) / (width + margin)
+      t_height = (img.h-margin) / (height + margin)
+      tiles = []
+      i = 0
+      while i < t_height do
+        j = 0;
+        while j < t_width do
+          tiles << img.copy_rect(j*(width+margin)+margin, i*(height+margin)+margin, width, height)
+          tiles[tiles.length - 1].set_color_key(SDL::SRCCOLORKEY, color_key) if transparent == true
+          j += 1
+        end
+        i += 1
+      end
+      tiles
+    end
+
+    #Draw image
+    def draw
+      SDL::Surface.blit(@image, @src_x, @src_y, @width, @height, SDL.get_video_surface, @x, @y)
+    end
+  end
+
+  class Tilemap < Layer
+    attr_accessor :obstacle
+    def initialize(tiles, obstacle = false)
+      super()
+      @tiles = tiles
+      @obstacle = obstacle
+      @width = 0
+      @height = 0
+      @map = [[]]
+      if @obstacle == true
+        @collide_id = $bg_cmap.length
+      end
+    end
+
+    #Load map from array
+    def load_map(map, width, height)
+      @map = map
+      @width = width
+      @height = height
+      if @obstacle == true
+        $bg_cmap[@collide_id] = []
+        for i in 0..@height - 1
+          for j in 0..@width - 1
+            $bg_cmap[@collide_id] << {:map => @tiles[@map[i][j]].make_collision_map, :x => j*@tiles[@map[i][j]].w+@x, :y => i*@tiles[@map[i][j]].h+@y}
+          end
+        end
+      end
+    end
+
+    #Draw tilemap
+    def draw
+      if @visible == true
+        for i in 0..@height -1
+          for j in 0..@width - 1
+            draw_tile(@tiles[@map[i][j]], j*@tiles[@map[i][j]].w+@x, i*@tiles[@map[i][j]].h+@y)
+          end
+        end
+      end
+    end
+
+    private
+    #Draw tile
+    def draw_tile(image, x, y)
+      SDL::Surface.blit(image, 0, 0, image.w, image.h, SDL.get_video_surface, x - @@window.scene.camera.x, y - @@window.scene.camera.y)
+    end
+  end
+
+  class Sprite < Layer
+    attr_accessor :frames, :delay, :direction
+    attr_writer :animate
+    def initialize(filename,width,height,transparent=false)
+      super()
+      @tiles = Image.to_tiles(filename, width, height, transparent)
+      @width = width
+      @height = height
+      @frames = []
+      @frame = 0
+      @delay = 200
+      @last_update = 0
+      @direction = :right
+      @visible = true
+      @animate = true
+      @tile
+      @cmap
+    end
+
+    #Go to first frame
+    def first_frame
+      @frame = 0
+    end
+
+    #Go to last frame
+    def last_frame
+      @frame = @frames.length - 1
+    end
+
+    #Go to next frame
+    def next_frame
+      @frame += 1
+      first_frame if @frame > @frames.length - 1
+    end
+
+    #Go to previous frame
+    def prev_frame
+      @frame -= 1
+      last_frame if @frame < 0
+    end
+
+    #Go to parameter frame
+    def go_frame(frame)
+      @frame = frame
+    end
+
+    #Draw sprite
+    def draw
+      animate if @animate == true
+      first_frame if @frames[@frame].nil?
+      draw_tile(@tiles[@frames[@frame]], @x, @y) if @visible == true
+    end
+
+    private
+    #Draw current frame
+    def draw_tile(image, x, y)
+      SDL::Surface.blit(image, 0, 0, image.w, image.h, SDL.get_video_surface, x - @@window.scene.camera.x, y - @@window.scene.camera.y)
+    end
+
+    #Animate sprite
+    def animate
+      curtime = SDL.get_ticks
+      while curtime >= (@last_update + @delay)
+        @last_update += @delay
+        next_frame
+      end
+    end
+  end
+
+  class Timer
+    def initialize
+      @start_ticks = 0
+      @paused_ticks = 0
+      @paused = false
+      @started = false
+    end
+
+    #Start counter timer
+    def start
+      @started = true
+      @paused = false
+      @start_ticks = SDL.get_ticks
+    end
+
+    #Stop counter timer
+    def stop
+      @started = false
+      @paused = false
+    end
+
+    #Pause counter timer
+    def pause
+      if @started == true && @paused == false
+        @paused = true
+        @paused_ticks = SDL.get_ticks - @start_ticks
+      end
+    end
+
+    #Resume counter timer
+    def resume
+      if @paused == true
+        @paused = false
+        @start_ticks = SDL.get_ticks - @paused_ticks
+        @paused_ticks = 0
+      end
+    end
+
+    #Return current tick
+    def ticks
+      t = 0
+      if @started == true
+        if @paused == true
+          t = @paused_ticks
+        else
+          t = SDL.get_ticks - @start_ticks
+        end
+      end
+      t
+    end
+
+    #Return true if started == true
+    def started?
+      @started
+    end
+
+    #Return true if paused == true
+    def paused?
+      @paused
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: xibe
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michel Brito
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-10 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: Developer Game
+email: micheljunio@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/xibe.rb
+has_rdoc: true
+homepage: http://codesheep.com/xibe/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: xibe
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Developer Game
+test_files: []
+