openrgss 0.1.1-x86-mingw32 → 0.1.2-x86-mingw32

data/lib/openrgss.rb

@@ -0,0 +1,19 @@
+require_relative 'openrgss/rgss'
+
+require_relative 'openrgss/bitmap'
+require_relative 'openrgss/color'
+require_relative 'openrgss/font'
+require_relative 'openrgss/plane'
+require_relative 'openrgss/rect'
+require_relative 'openrgss/sprite'
+require_relative 'openrgss/table'
+require_relative 'openrgss/tilemap'
+require_relative 'openrgss/tone'
+require_relative 'openrgss/viewport'
+require_relative 'openrgss/window'
+require_relative 'openrgss/rgsserror'
+require_relative 'openrgss/rgssreset'
+
+require_relative 'openrgss/audio'
+require_relative 'openrgss/graphics'
+require_relative 'openrgss/input'

data/lib/openrgss/audio.rb

@@ -0,0 +1,109 @@
+# The module that carries out music and sound processing.
+module Audio
+  class <<self
+
+    # Prepares MIDI playback by DirectMusic.
+    #
+    # A method of the processing at startup in RGSS2 for enabling execution at any time.
+    #
+    # MIDI playback is possible without calling this method, but in Windows Vista or later, a delay of 1 to 2 seconds will result at playback.
+
+    def setup_mdi
+
+    end
+
+    # Starts BGM playback. Specifies the file name, volume, pitch, and playback starting position in that order.
+    #
+    # The playback starting position (RGSS3) is only valid for ogg or wav files.
+    #
+    # Also automatically searches files included in RGSS-RTP. File extensions may be omitted.
+
+    def bgm_play(filename, volume=100, pitch=100, pos=0)
+      SDL::Mixer.play_music SDL::Mixer::Music.load(RGSS.get_file(filename)), -1
+    end
+
+    # Stops BGM playback.
+
+    def bgm_stop
+      SDL::Mixer.halt_music
+    end
+
+    # Starts BGM fadeout. time is the length of the fadeout in milliseconds.
+
+    def bgm_fade(time)
+      SDL::Mixer.fade_out_music(time)
+    end
+
+    # Gets the playback position of the BGM. Only valid for ogg or wav files. Returns 0 when not valid.
+
+    def bgm_pos
+
+    end
+
+    # Starts BGS playback. Specifies the file name, volume, pitch, and playback starting position in that order.
+    #
+    # The playback starting position (RGSS3) is only valid for ogg or wav files.
+    #
+    # Also automatically searches files included in RGSS-RTP. File extensions may be omitted.
+
+    def bgs_play(filename, volume=100, pitch=100, pos=0)
+      @bgs_channel = SDL::Mixer.play_channel(-1, SDL::Mixer::Wave.load(RGSS.get_file(filename)), -1)
+    end
+
+    # Stops BGS playback.
+
+    def bgs_stop
+      SDL::Mixer.halt(@bgs_channel) if @bgs_channel
+    end
+
+    # Starts BGS fadeout. time is the length of the fadeout in milliseconds.
+
+    def bgs_fade(time)
+      SDL::Mixer.fade_out(@bgs_channel, time) if @bgs_channel
+    end
+
+    # Gets the playback position of the BGS. Only valid for ogg or wav files. Returns 0 when not valid.
+
+    def bgs_pos
+
+    end
+
+    # Starts ME playback. Sets the file name, volume, and pitch in turn.
+    #
+    # Also automatically searches files included in RGSS-RTP. File extensions may be omitted.
+    #
+    # When ME is playing, the BGM will temporarily stop. The timing of when the BGM restarts is slightly different from RGSS1.
+
+    def me_play(filename, volume=100, pitch=100)
+      @me_channel = SDL::Mixer.play_channel(-1, SDL::Mixer::Wave.load(RGSS.get_file(filename)), 0)
+    end
+
+    # Stops ME playback.
+
+    def me_stop
+      SDL::Mixer.halt(@me_channel) if @me_channel
+    end
+
+    # Starts ME fadeout. time is the length of the fadeout in milliseconds.
+
+    def me_fade(time)
+      SDL::Mixer.fade_out(@me_channel, time) if @me_channel
+    end
+
+    # Starts SE playback. Sets the file name, volume, and pitch in turn.
+    #
+    # Also automatically searches files included in RGSS-RTP. File extensions may be omitted.
+    #
+    # When attempting to play the same SE more than once in a very short period, they will automatically be filtered to prevent choppy playback
+
+    def se_play(filename, volume=100, pitch=100)
+      @se_channel = SDL::Mixer.play_channel(-1, SDL::Mixer::Wave.load(RGSS.get_file(filename)), 0)
+    end
+
+    # Stops all SE playback.
+
+    def se_stop
+      SDL::Mixer.halt(@se_channel) if @me_channel
+    end
+  end
+end

data/lib/openrgss/bitmap.rb

@@ -0,0 +1,255 @@
+# The bitmap class. Bitmaps represent images.
+#
+# Sprites (Sprite) and other objects must be used to display bitmaps onscreen.
+
+class Bitmap
+  attr_accessor :font, :entity, :text
+
+  # :call-seq:
+  #  Bitmap.new(filename)
+  #  Bitmap.new(width, height)
+  #
+  # Loads the graphic file specified in filename or size and creates a bitmap object.
+  #
+  # Also automatically searches files included in RGSS-RTP and encrypted archives. File extensions may be omitted.
+
+  def initialize(width, height=nil)
+    @entity = if width.is_a? String
+      filename = width
+      filepath = RGSS.get_file(filename)
+      Log.debug('load bitmap') { filepath }
+      SDL::Surface.load(filepath).display_format_alpha
+    else
+      big_endian = ([1].pack("N") == [1].pack("L"))
+      if big_endian
+        rmask = 0xff000000
+        gmask = 0x00ff0000
+        bmask = 0x0000ff00
+        amask = 0x000000ff
+      else
+        rmask = 0x000000ff
+        gmask = 0x0000ff00
+        bmask = 0x00ff0000
+        amask = 0xff000000
+      end
+      SDL::Surface.new(SDL::SWSURFACE|SDL::SRCALPHA, width, height, 32, rmask, gmask, bmask, amask)
+    end
+    @font   = Font.new
+    # @text = [] ~
+  end
+
+  # Frees the bitmap. If the bitmap has already been freed, does nothing.
+
+  def dispose
+    @entity.destroy
+  end
+
+  # Returns true if the bitmap has been freed.
+
+  def disposed?
+    @entity.destroyed?
+  end
+
+  # Gets the bitmap width.
+
+  def width
+    @entity.w
+  end
+
+  # Gets the bitmap height.
+
+  def height
+    @entity.h
+  end
+
+  # Gets the bitmap rectangle (Rect).
+
+  def rect
+    Rect.new(0, 0, width, height)
+  end
+
+  def clone
+    b        =Bitmap.new(width, height)
+    b.entity = @entity.copyRect(0, 0, width, height)
+    b.font   =Font.clone
+    return b
+  end
+
+  # Performs a block transfer from the src_bitmap box src_rect (Rect) to the specified bitmap coordinates (x, y).
+  #
+  # opacity can be set from 0 to 255.
+
+  def blt(x, y, src_bitmap, src_rect, opacity=255)
+    src_bitmap.entity.set_alpha(SDL::RLEACCEL, opacity)
+    SDL::Surface.blit(src_bitmap.entity, src_rect.x, src_rect.y, src_rect.width, src_rect.height, @entity, x, y)
+    src_bitmap.entity.set_alpha(SDL::SRCALPHA|SDL::RLEACCEL, 255)
+  end
+
+  # Performs a block transfer from the src_bitmap box src_rect (Rect) to the specified bitmap box dest_rect (Rect).
+  #
+  # opacity can be set from 0 to 255.
+
+  def stretch_blt(dest_rect, src_bitmap, src_rect, opacity=255)
+    src_bitmap.entity.set_alpha(SDL::RLEACCEL, opacity)
+    SDL::Surface.transform_blit(src_bitmap.entity, @entity, 0, src_rect.width.to_f / dest_rect.width, src_rect.height.to_f / dest_rect.height, src_rect.x, src_rect.y, dest_rect.x, dest_rect.y, SDL::Surface::TRANSFORM_AA)
+    src_bitmap.entity.set_alpha(SDL::SRCALPHA|SDL::RLEACCEL, 255)
+  end
+
+  # :call-seq:
+  # fill_rect(x, y, width, height, color)
+  # fill_rect(rect, color)
+  #
+  # Fills the bitmap box (x, y, width, height) or rect (Rect) with color (Color).
+
+  def fill_rect(x, y, width=nil, height=nil, color=nil)
+    if x.is_a? Rect
+      rect   = x
+      color  = y
+      x      = rect.x
+      y      = rect.y
+      width  = rect.width
+      height = rect.height
+    end
+    @entity.fill_rect(x, y, width, height, @entity.map_rgba(color.red, color.green, color.blue, color.alpha))
+  end
+
+  # :call-seq:
+  # gradient_fill_rect(x, y, width, height, color1, color2[, vertical])
+  # gradient_fill_rect(rect, color1, color2[, vertical])
+  #
+  # Fills in this bitmap box (x, y, width, height) or rect (Rect) with a gradient from color1 (Color) to color2 (Color).
+  #
+  # Set vertical to true to create a vertical gradient. Horizontal gradient is the default.
+
+  def gradient_fill_rect(x, y, width, height=false, color1=nil, color2=nil, vertical=false)
+    if x.is_a? Rect
+      rect     = x
+      color1   = y
+      color2   = width
+      vertical = height
+      x        = rect.x
+      y        = rect.y
+      width    = rect.width
+      height   = rect.height
+    end
+    if vertical
+      height.times do |i|
+        @entity.fill_rect(x, y+i, width, 1, @entity.map_rgba(
+            color1.red + (color2.red - color1.red) * i / height,
+            color1.green + (color2.green - color1.green) * i / height,
+            color1.blue + (color2.blue - color1.blue) * i / height,
+            color1.alpha + (color2.alpha - color1.alpha) * i / height
+        ))
+      end
+    else
+      width.times do |i|
+        @entity.fill_rect(x+i, y, 1, height, @entity.map_rgba(
+            color1.red + (color2.red - color1.red) * i / width,
+            color1.green + (color2.green - color1.green) * i / width,
+            color1.blue + (color2.blue - color1.blue) * i / width,
+            color1.alpha + (color2.alpha - color1.alpha) * i / width
+        ))
+      end
+    end
+  end
+
+  # Clears the entire bitmap.
+
+  def clear
+    @entity.fill_rect(0, 0, width, height, 0x00000000)
+  end
+
+  # Clears this bitmap box or (x, y, width, height) or rect (Rect).
+
+  def clear_rect(x, y=nil, width=nil, height=nil)
+    if x.is_a? Rect
+      rect   = x
+      x      = rect.x
+      y      = rect.y
+      width  = rect.width
+      height = rect.height
+    end
+    @entity.fill_rect(x, y, width, height, 0x00000000)
+  end
+
+  # Gets the color (Color) at the specified pixel (x, y).
+
+  def get_pixel(x, y)
+
+    color = @entity.format.getRGBA(@entity.get_pixel(x, y))
+    return Color.new(color[0], color[1], color[2], color[3])
+    #Color.new((color & @entity.Rmask) >> @entity.Rshift, (color & @entity.Gmask) >> @entity.Gshift, (color & @entity.Bmask) >> @entity.Bshift, (color & @entity.Amask) >> @entity.Ashift)
+  end
+
+  # Sets the specified pixel (x, y) to color (Color).
+
+  def set_pixel(x, y, color)
+    @entity.put_pixel(x, y, @entity.map_rgba(color.red, color.green, color.blue, color.alpha))
+  end
+
+  # Changes the bitmap's hue within 360 degrees of displacement.
+  #
+  # This process is time-consuming. Furthermore, due to conversion errors, repeated hue changes may result in color loss.
+
+  def hue_change(hue)
+
+  end
+
+  # Applies a blur effect to the bitmap. This process is time consuming.
+
+  def blur
+
+  end
+
+  # Applies a radial blur to the bitmap. angle is used to specify an angle from 0 to 360. The larger the number, the greater the roundness.
+  #
+  # division is the division number (from 2 to 100). The larger the number, the smoother it will be. This process is very time consuming.
+
+  def radial_blur(angle, division)
+
+  end
+
+  # Draws the string str in the bitmap box (x, y, width, height) or rect (Rect).
+  #
+  # If str is not a character string object, it will be converted to a character string using the to_s method before processing is performed.
+  #
+  # If the text length exceeds the box's width, the text width will automatically be reduced by up to 60 percent.
+  #
+  # Horizontal text is left-aligned by default. Set align to 1 to center the text and to 2 to right-align it. Vertical text is always centered.
+  #
+  # As this process is time-consuming, redrawing the text with every frame is not recommended.
+
+  def draw_text(x, y, width=0, height=nil, str=nil, align=0 )
+    if x.is_a? Rect
+      rect  = x
+      str   = y
+      align = width
+
+      x      = rect.x
+      y      = rect.y
+      width  = rect.width
+      height = rect.height
+    end
+
+    str = str.to_s
+    if align == 2
+      x += width - @font.entity.text_size(str)[0]
+    elsif align == 1
+      x += (width - @font.entity.text_size(str)[0]) / 2
+    end
+
+    # @text << [str, x, y, @font.color.red, @font.color.green, @font.color.blue] See you ~
+    tmp = @font.entity.render_blended_utf8(str,  @font.color.red, @font.color.green, @font.color.blue)
+    tmp.set_alpha(SDL::RLEACCEL ,0)
+    @entity.put tmp,x,y
+    #SDL::Surface.transformBlit tmp,@entity,0,1,1,0,0,x, y,SDL::Surface::TRANSFORM_AA|SDL::Surface::TRANSFORM_SAFE|SDL::Surface::TRANSFORM_SAFE
+  end
+
+  # Gets the box (Rect) used when drawing the string str with the draw_text method. Does not include the outline portion (RGSS3) and the angled portions of italicized text.
+  #
+  # If str is not a character string object, it will be converted to a character string using the to_s method before processing is performed.
+
+  def text_size(str)
+    Rect.new 0, 0, *@font.entity.text_size(str)
+  end
+end

data/lib/openrgss/color.rb

@@ -0,0 +1,106 @@
+# The RGBA color class. Each component is handled with a floating-point value (Float).
+class Color
+
+  # :call-seq:
+  # Color.new(red, green, blue[, alpha])
+  # Color.new
+  #
+  # Creates a Color object. If alpha is omitted, it is assumed to be 255.
+  #
+  # The default values when no arguments are specified are (0, 0, 0, 0).
+
+  def initialize(red=0, green=0, blue=0, alpha = 255)
+    @red   = red
+    @blue  = blue
+    @green = green
+    @alpha = alpha
+  end
+
+  # :call-seq:
+  # set(red, green, blue[, alpha])
+  # set(color)
+  #
+  # Sets all components at once.
+  #
+  # The second format copies all the components from a separate Color object.
+
+  def set(red, blue=0, green=0, alpha = 255)
+    if red.is_a? Color
+      color  = red
+      @red   = color.red
+      @blue  = color.blue
+      @green = color.green
+      @alpha = color.alpha
+    else
+      @red   = red
+      @blue  = blue
+      @green = green
+      @alpha = alpha
+    end
+    return self
+  end
+
+  # The red value (0-255). Out-of-range values are automatically corrected.
+  attr_accessor :red
+
+  # The green value (0-255). Out-of-range values are automatically corrected.
+  attr_accessor :blue
+
+  # The blue value (0-255). Out-of-range values are automatically corrected.
+  attr_accessor :green
+
+  # The alpha value (0-255). Out-of-range values are automatically corrected.
+  attr_accessor :alpha
+
+  def to_s() # :nodoc:
+    "(#{@red}, #{@blue}, #{@green}, #{@alpha})"
+  end
+
+  def _dump(depth = 0) # :nodoc:
+    [@red, @green, @blue, @alpha].pack('D*')
+  end
+
+  def self._load(string) # :nodoc:
+    self.new(*string.unpack('D*')) #fix by zh99998
+  end
+
+  def red=(val) # :nodoc:
+    @red = [[0, val].max, 255].min
+  end
+
+  def blue=(val) # :nodoc:
+    @blue = [[0, val].max, 255].min
+  end
+
+  def green=(val) # :nodoc:
+    @green = [[0, val].max, 255].min
+  end
+
+  def alpha=(val) # :nodoc:
+    @alpha = [[0, val].max, 255].min
+  end
+
+  def ==(other) # :nodoc:
+    raise TypeError.new("can't convert #{other.class} into Color") unless self.class == other.class
+    return @red == other.red &&
+        @green == other.green &&
+        @blue == other.blue &&
+        @alpha == other.alpha
+  end
+
+  def ===(other) # :nodoc:
+    raise TypeError.new("can't convert #{other.class} into Color") unless self.class == other.class
+    return @red == other.red &&
+        @green == other.green &&
+        @blue == other.blue &&
+        @alpha == other.alpha
+  end
+
+  def egl?(other) # :nodoc:
+    raise TypeError.new("can't convert #{other.class} into Color") unless self.class == other.class
+    return @red == other.red &&
+        @green == other.green &&
+        @blue == other.blue &&
+        @alpha == other.alpha
+  end
+end