openrgss 0.1 → 0.1.2

data/lib/openrgss/font.rb

@@ -0,0 +1,106 @@
+# The font class. Font is a property of the Bitmap class.
+#
+# If there is a "Fonts" folder directly under the game folder, the font files in it can be used even if they are not installed on the system.
+#
+# You can change the default values set for each component when a new Font object is created.
+#
+#  Font.default_name = ["Myriad", "Verdana"]
+#  Font.default_size = 22
+#  Font.default_bold = true
+
+class Font
+  @@cache = {}
+  # Creates a Font object.
+
+  def initialize(arg_name=@@default_name, arg_size=@@default_size)
+    @name  = arg_name
+    @size  = arg_size
+    @bold  = @@default_bold
+    @italic= @@default_italic
+    @color = @@default_color
+  end
+
+  # Returns true if the specified font exists on the system.
+
+  def Font.exist?(arg_font_name)
+    font_key       = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts'
+    reg_open_keyex = Win32API.new('Advapi32', 'RegOpenKeyEx', 'lpllp', 'l')
+    reg_enum_value = Win32API.new('Advapi32', 'RegEnumValue', 'llppiiii', 'l')
+    reg_close_key  = Win32API.new('Advapi32', 'RegCloseKey', 'l', 'l')
+    open_key       = [0].pack('V')
+    # get key
+    reg_open_keyex.call(0x80000002, font_key, 0, 0x20019, open_key)
+    open_key  = (open_key + [0].pack('V')).unpack('V').first
+    # enumerate
+    buffer    = "\0"*256
+    buff_size = [255].pack('l')
+    key_i     = 0
+    font_names= []
+    while (reg_enum_value.call(open_key, key_i, buffer, buff_size, 0, 0, 0, 0).zero?)
+      # get name
+      font_names << buffer[0, buff_size.unpack('l').first].sub(/\s\(.*\)/, '')
+      # reset
+      buff_size = [255].pack('l')
+      # increment
+      key_i     += 1
+    end
+    reg_close_key.call(open_key)
+    # test
+    return font_names.include?(arg_font_name)
+  end
+
+  # SDL::TTF对象
+
+  def entity
+    result       = @@cache[[@name, @size]] ||= SDL::TTF.open('wqy-microhei.ttc', @size)
+    result.style = (@bold ? SDL::TTF::STYLE_BOLD : 0) | (@italic ? SDL::TTF::STYLE_ITALIC : 0)
+    result
+  end
+
+  # The font name. Include an array of strings to specify multiple fonts to be used in a desired order.
+  #
+  #  font.name = ["Myriad", "Verdana"]
+  # In this example, if the higher priority font Myriad does not exist on the system, the second choice Verdana will be used instead.
+  #
+  # The default is ["Verdana", "Arial", "Courier New"].
+  attr_accessor :name
+
+  # The font size. The default is 24.
+  attr_accessor :size
+
+  # The bold flag. The default is FALSE.
+  attr_accessor :bold
+
+  # The italic flag. The default is FALSE.
+  attr_accessor :italic
+
+  # The flag for outline text. The default is TRUE.
+  attr_accessor :outline
+
+  # The flag for shadow text. The default is false (RGSS3). When enabled, a black shadow will be drawn to the bottom right of the character.
+  attr_accessor :shadow
+
+  # The font color (Color). Alpha values may also be used. The default is (255,255,255,255).
+  #
+  # Alpha values are also used when drawing outline (RGSS3) and shadow text.
+  attr_accessor :color
+
+  # The outline color (Color). The default is (0,0,0,128).
+  attr_accessor :out_color
+
+  class <<self
+    [:name, :size, :bold, :italic, :color, :outline, :shadow, :out_color].each { |attribute|
+      name = 'default_' + attribute.to_s
+      define_method(name) { class_variable_get('@@'+name) }
+      define_method(name+'=') { |value| class_variable_set('@@'+name, value) }
+    }
+  end
+  #------------------------------------------------------------------------
+  # * Standard Einstellungen aus der RGSS102E.dll.
+  #------------------------------------------------------------------------
+  @@default_name  = "Arial"
+  @@default_size  = 22
+  @@default_bold  = false
+  @@default_italic= false
+  @@default_color = Color.new(255, 255, 255, 255)
+end

data/lib/openrgss/graphics.rb

@@ -0,0 +1,150 @@
+module Graphics
+  FPS_COUNT               = 30
+  @frame_rate             = 60
+  @frame_count            = 0
+  @frame_count_recent     = 0
+  @skip                   = 0
+  @ticks                  = 0
+  @fps_ticks              = 0
+  @brightness             = 255
+  @width                  = 640
+  @height                 = 480
+  @graphics_render_target = Bitmap.new(544, 416) # need rebuild when resize.
+  @freeze                 = false                # or true?
+  class <<self
+    attr_reader :width, :height
+    attr_accessor :entity
+    attr_accessor :frame_rate, :frame_count, :brightness
+
+    attr_reader :real_fps
+
+    def resize_screen(width, height)
+      @width  = width
+      @height = height
+    end
+
+    def update
+      RGSS.update
+      @frame_count += 1
+      if @skip >= 10 or SDL.get_ticks < @ticks + 1000 / frame_rate
+        @entity.fill_rect(0, 0, @width, @height, 0x000000)
+        if (@old_resources!=RGSS.resources) # Maybe here can make a dirty mark
+          RGSS.resources.sort!
+          @old_resources=RGSS.resources.clone
+        end
+
+        unless @freezed # redraw only when !freezed
+          @graphics_render_target.entity.fill_rect(0, 0, @width, @height, @graphics_render_target.entity.map_rgba(0, 0, 0, 255))
+          @graphics_render_target.entity.set_alpha(SDL::RLEACCEL, 0)
+          RGSS.resources.each { |resource| resource.draw(@graphics_render_target) }
+        end
+        @entity.put @graphics_render_target.entity, 0, 0
+        @entity.drawRect(0, 0, @width, @height, @entity.map_rgb(0, 0, 0), true, 255-@brightness) # draw gray layout
+        @entity.update_rect(0, 0, 0, 0)
+        sleeptime = @ticks + 1000.0 / frame_rate - SDL.get_ticks
+        sleep sleeptime.to_f / 1000 if sleeptime > 0
+
+        @skip  = 0
+        @ticks = SDL.get_ticks
+      else
+        @skip += 1
+      end
+
+      @frame_count_recent += 1
+      if @frame_count_recent >= FPS_COUNT
+        @frame_count_recent = 0
+        now                 = SDL.get_ticks
+        @real_fps           = FPS_COUNT * 1000 / (now - @fps_ticks)
+        @fps_ticks          = now
+      end
+    end
+
+    def wait(duration)
+      duration.times { update }
+    end
+
+    def fadeout(duration)
+      step=255/duration
+      duration.times { |i| @brightness=255-i*step; update }
+      @brightness=0
+    end
+
+    def fadein(duration)
+      step=255/duration
+      duration.times { |i| @brightness=i*step; update }
+      @brightness=255
+    end
+
+    def freeze
+      @freezed=true
+    end
+
+    def transition(duration=10, filename=nil, vague=40)
+      if (duration==0)
+        @freezed=false; return;
+      end
+      if (filename.nil?) #
+        imgmap=Array.new(@width) { Array.new(@height) { 255 } }
+      else #
+        b     =Bitmap.new(filename); pfb = b.entity.format
+        imgmap=Array.new(@width) { |x| Array.new(@height) { |y| [pfb.get_rgb(b.entity[x, y])[0], 1].max } }
+                         #TODO : free
+      end
+      step      =255/duration
+      new_frame = Bitmap.new(@width, @height)
+      RGSS.resources.sort!
+      @old_resources=RGSS.resources.clone
+      new_frame.entity.fill_rect(0, 0, @width, @height, new_frame.entity.map_rgba(0, 0, 0, 255))
+      new_frame.entity.set_alpha(SDL::SRCALPHA, 255)
+      RGSS.resources.each { |resource| resource.draw(new_frame) }
+                                                                                                     # draw frame to bitmap
+
+      pf = new_frame.entity.format
+      new_frame.entity.lock
+      picmap=Array.new(@width) { |x| Array.new(@height) { |y| pf.getRGBA(new_frame.entity[x, y]) } } # better to use bit calculate
+      new_frame.entity.unlock
+      maker = Bitmap.new(@width, @height)
+                                                                                                     # create pre-render layoyt
+      maker.entity.fill_rect(0, 0, @width, @height, new_frame.entity.map_rgba(0, 0, 0, 255))
+      maker.entity.put @graphics_render_target.entity, 0, 0
+                                                                                                     # transition layout
+      new_frame.entity.lock
+      @width.times { |x| @height.times { |y|
+        if (imgmap[x][y]!=0)
+          new_frame.entity[x, y]=pf.map_rgba(picmap[x][y][0], picmap[x][y][1], picmap[x][y][2], [255/(duration/(255.0/imgmap[x][y])), 255].min)
+          #TODO : alpha will be 255 after many render.it's different fron RPG Maker
+        else
+          new_frame.entity[x, y]=pf.map_rgba(picmap[x][y][0], picmap[x][y][1], picmap[x][y][2], 255)
+        end
+      } }
+      new_frame.entity.unlock
+      duration.times { |i|
+        @entity.fill_rect(0, 0, @width, @height, 0x000000)
+        maker.entity.put new_frame.entity, 0, 0 # alpha
+        @entity.put maker.entity, 0, 0
+        @entity.update_rect(0, 0, 0, 0)
+      }
+                                                                                                     # TODO: free
+      @graphics_render_target.entity.set_alpha(0, 255); @freezed=false; @brightness=255; update
+    end
+
+    def snap_to_bitmap
+      return @graphics_render_target.clone # free
+    end
+
+    def frame_reset
+
+    end
+
+    def play_movie(filename)
+
+    end
+
+    def brightness=(brightness)
+      @brightness = brightness < 0 ? 0 : brightness > 255 ? 255 : brightness
+      #gamma       = @brightness.to_f / 255
+      #SDL::Screen.set_gamma(5,1,1)
+      #seems SDL::Screen.set_gamma and SDL::Screen.set_gamma_rmap doesn't work
+    end
+  end
+end

data/lib/openrgss/input.rb

@@ -0,0 +1,141 @@
+# A module that handles input data from a gamepad or keyboard.
+#
+# Managed by symbols rather than button numbers in RGSS3. (RGSS3)
+module Input
+  Keys = {
+      DOWN:     [SDL::Key::DOWN, SDL::Key::S],
+      LEFT:     [SDL::Key::LEFT, SDL::Key::A],
+      RIGHT:    [SDL::Key::RIGHT, SDL::Key::D],
+      UP:       [SDL::Key::UP, SDL::Key::W],
+      A:        [SDL::Key::LSHIFT],
+      B:        [SDL::Key::X, SDL::Key::ESCAPE],
+      C:        [SDL::Key::Z, SDL::Key::RETURN],
+      L:        [SDL::Key::PAGEUP],
+      R:        [SDL::Key::PAGEDOWN],
+      SHIFT:    [SDL::Key::LSHIFT, SDL::Key::RSHIFT],
+      CTRL:     [SDL::Key::LSHIFT, SDL::Key::RSHIFT],
+      ALT:      [SDL::Key::LSHIFT, SDL::Key::RSHIFT],
+      F5:       [SDL::Key::F5],
+      F6:       [SDL::Key::F6],
+      F7:       [SDL::Key::F7],
+      F8:       [SDL::Key::F8],
+      F9:       [SDL::Key::F9],
+      SHOW_FPS: [SDL::Key::F2],
+      RESET:    [SDL::Key::F12]
+  }
+
+  Entities = {}
+
+  Keys.each { |key, value|
+    const_set(key, key)
+    value.each { |entity| Entities[entity] = key }
+
+  }
+  @status = {}
+  @events = []
+  class <<self
+    attr_accessor :events
+
+    # Updates input data. As a general rule, this method is called once per frame.
+
+    def update
+      RGSS.update
+      @status.each { |key, value| @status[key] = value.next }
+      while event = events.shift
+        key = Entities[event.sym]
+        Log.debug('key') { event }
+        if event.press
+          case key
+          when :SHOW_FPS
+            RGSS.show_fps = !RGSS.show_fps
+          when :RESET
+            raise RGSSReset
+          else
+            @status[key] = 0
+          end
+        else
+          @status.delete key
+        end
+      end
+    end
+
+    # Determines whether the button corresponding to the symbol sym is currently being pressed.
+    #
+    # If the button is being pressed, returns TRUE. If not, returns FALSE.
+    #
+    #  if Input.press?(:C)
+    #    do_something
+    #  end
+
+    def press?(sym)
+      @status[sym]
+    end
+
+    # Determines whether the button corresponding to the symbol sym is currently being pressed again.
+    #
+    # "Pressed again" is seen as time having passed between the button being not pressed and being pressed.
+    #
+    # If the button is being pressed, returns TRUE. If not, returns FALSE.
+
+    def trigger?(sym)
+      @status[sym] and @status[sym].zero?
+    end
+
+    # Determines whether the button corresponding to the symbol sym is currently being pressed again.
+    #
+    # Unlike trigger?, takes into account the repeated input of a button being held down continuously.
+    #
+    # If the button is being pressed, returns TRUE. If not, returns FALSE.
+
+    def repeat?(sym)
+      @status[sym] and (@status[sym].zero? or (@status[sym] > 10 and (@status[sym] % 4).zero?))
+    end
+
+    # Checks the status of the directional buttons, translates the data into a specialized 4-direction input format, and returns the number pad equivalent (2, 4, 6, 8).
+    #
+    # If no directional buttons are being pressed (or the equivalent), returns 0.
+
+    def dir4
+      case
+      when @status[:DOWN]
+        2
+      when @status[:LEFT]
+        4
+      when @status[:RIGHT]
+        6
+      when @status[:UP]
+        8
+      else
+        0
+      end
+    end
+
+    # Checks the status of the directional buttons, translates the data into a specialized 8-direction input format, and returns the number pad equivalent (1, 2, 3, 4, 6, 7, 8, 9).
+    #
+    # If no directional buttons are being pressed (or the equivalent), returns 0.
+
+    def dir8
+      case
+      when @status[:DOWN] && @status[:LEFT]
+        1
+      when @status[:DOWN] && @status[:RIGHT]
+        3
+      when @status[:DOWN]
+        2
+      when @status[:UP] && @status[:LEFT]
+        7
+      when @status[:UP] && @status[:RIGHT]
+        9
+      when @status[:UP]
+        8
+      when @status[:LEFT]
+        4
+      when @status[:RIGHT]
+        6
+      else
+        0
+      end
+    end
+  end
+
+end

data/lib/openrgss/plane.rb

@@ -0,0 +1,102 @@
+# The Plane class. Planes are special sprites that tile bitmap patterns across the entire screen and are used to display parallax backgrounds and so on.
+class Plane
+
+  # Refers to the bitmap (Bitmap) used in the plane.
+  #attr_accessor :bitmap
+
+  # Refers to the viewport (Viewport) associated with the plane.
+  #attr_accessor :viewport
+
+  # The plane's visibility. If TRUE, the plane is visible. The default value is TRUE.
+  #attr_accessor :visible
+
+  # The plane's z-coordinate. The larger the value, the closer to the player the plane will be displayed.
+  #
+  # If multiple objects share the same z-coordinate, the more recently created object will be displayed closest to the player.
+  #attr_accessor :z
+
+  # The x-coordinate of the plane's starting point. Change this value to scroll the plane.
+  attr_accessor :ox
+
+  # The y-coordinate of the plane's starting point. Change this value to scroll the plane.
+  attr_accessor :oy
+
+  # The plane's x-axis zoom level. 1.0 denotes actual pixel size.
+  #attr_accessor :zoom_x
+
+  # The plane's y-axis zoom level. 1.0 denotes actual pixel size.
+  #attr_accessor :zoom_y
+
+  # The plane's opacity (0-255). Out-of-range values are automatically corrected.
+  #attr_accessor :opacity
+
+  # The plane's blending mode (0: normal, 1: addition, 2: subtraction).
+  #attr_accessor :blend_type
+
+  # The color (Color) to be blended with the plane. Alpha values are used in the blending ratio.
+  #attr_accessor :color
+
+  # The plane's color tone (Tone).
+  #attr_accessor :tone
+
+  # Creates a Plane object. Specifies a viewport (Viewport) when necessary.
+  def initialize(arg_viewport=nil)
+    @sprite = Sprite.new(arg_viewport)
+    @src_bitmap = nil
+  end
+
+  # Frees the plane. If the plane has already been freed, does nothing.
+
+  def dispose
+    @sprite.bitmap.dispose unless @sprite.bitmap.nil? or @sprite.bitmap.disposed?
+    @sprite.dispose unless @sprite.nil? or @sprite.disposed?
+  end
+
+  # Returns TRUE if the plane has been freed.
+
+  def disposed?
+    @sprite.nil? or @sprite.disposed?
+  end
+
+
+  def ox=(val)
+    @sprite.ox= (val % (@src_bitmap.nil? ? 1 : @src_bitmap.width))
+  end
+
+
+  def oy=(val)
+    @sprite.oy= (val % (@src_bitmap.nil? ? 1 : @src_bitmap.height))
+  end
+
+
+  def bitmap
+    @src_bitmap
+  end
+
+
+  def bitmap=(arg_bmp)
+    vp_width = @sprite.viewport.nil? ? \
+                            Graphics.width : @sprite.viewport.rect.width
+    vp_height = @sprite.viewport.nil? ? \
+                            Graphics.height : @sprite.viewport.rect.height
+    x_steps = [(vp_width / arg_bmp.width).ceil, 1].max * 2
+    y_steps = [(vp_height / arg_bmp.height).ceil, 1].max * 2
+
+    bmp_width = x_steps * arg_bmp.width
+    bmp_height = y_steps * arg_bmp.height
+
+    @src_bitmap = arg_bmp
+    @sprite.bitmap.dispose unless @sprite.bitmap.nil? or @sprite.bitmap.disposed?
+    @sprite.bitmap = Bitmap.new(bmp_width, bmp_height)
+
+    x_steps.times { |ix| y_steps.times { |iy|
+      @sprite.bitmap.blt(ix * arg_bmp.width, iy * arg_bmp.height,
+                         @src_bitmap, @src_bitmap.rect)
+    } }
+  end
+
+  def method_missing(symbol, *args)
+    @sprite.method(symbol).call(*args)
+  end
+
+end