rgss3 0.1.0 → 0.1.1

data/lib/rgss3/color.rb

@@ -0,0 +1,163 @@
+class Color
+
+  attr_accessor :gosu_color
+
+  def initialize(*args)
+    case args.size
+    when 0
+      empty
+    when 3, 4
+      set(*args)
+    else
+      raise ArgumentError
+    end
+  end
+
+  def set(*args)
+    case args.size
+    when 1
+      if args[0].is_a?(Color)
+        @gosu_color = args[0].to_gosu
+      else
+        raise ArgumentError
+      end
+    when 3
+      @gosu_color = Gosu::Color.rgba(*args.map(&:round), 255)
+    when 4
+      @gosu_color = Gosu::Color.rgba(*args.map(&:round))
+    else
+      raise ArgumentError
+    end
+  end
+
+  def red
+    @gosu_color.red.to_f
+  end
+
+  def blue
+    @gosu_color.blue.to_f
+  end
+
+  def green
+    @gosu_color.green.to_f
+  end
+
+  def alpha
+    @gosu_color.alpha.to_f
+  end
+
+  def red_i
+    @gosu_color.red
+  end
+
+  def blue_i
+    @gosu_color.blue
+  end
+
+  def green_i
+    @gosu_color.green
+  end
+
+  def alpha_i
+    @gosu_color.alpha
+  end
+
+  def empty
+    @gosu_color = Gosu::Color::NONE
+  end
+
+  def red=(value)
+    @gosu_color.red = value
+  end
+
+  def blue=(value)
+    @gosu_color.blue = value
+  end
+
+  def green=(value)
+    @gosu_color.green = value
+  end
+
+  def alpha=(value)
+    @gosu_color.alpha = value
+  end
+
+  def to_a
+    [red_i, green_i, blue_i, alpha_i]
+  end
+
+  alias_method :rgba, :to_a
+
+  def to_s
+    format '(%.6f, %.6f, %.6f, %.6f)', red, green, blue, alpha
+  end
+
+  alias_method :inspect, :to_s
+
+  def to_fa
+    [red, green, blue, alpha]
+  end
+
+  def to_gosu
+    @gosu_color.dup
+  end
+
+  def to_pixel
+    Magick::Pixel.from_color(to_rmagick_color)
+  end
+
+  def to_rmagick_color
+    "rgba(#{red_i},#{green_i},#{blue_i},#{alpha_i})"
+  end
+
+  def _dump(d = 0)
+    [red, green, blue, alpha].pack('d4')
+  end
+
+  def self._load(s)
+    new(*s.unpack('d4'))
+  end
+
+  def self.try_convert(color)
+    case color
+    when Color
+      color
+    when String
+      from_pixel Magick::Pixel.from_color(color)
+    when Integer
+      from_int(color)
+    when Magick::Pixel
+      from_pixel(color)
+    when Gosu::Color
+      from_gosu(color)
+    end
+  end
+
+  def self.from_pixel(pixel)
+    new(*rgba_from_pixel(pixel))
+  end
+
+  def self.rgba_from_pixel(pixel)
+    # "#RRGGBBAA"
+    rgba_hex = pixel.to_color(Magick::AllCompliance, true, 8, true)
+    rgba = rgba_hex[1, 8].to_i(16)
+    rgba_from_int(rgba)
+  end
+
+  def from_int(rgba)
+    new(*rgba_from_int(rgba))
+  end
+
+  def self.rgba_from_int(rgba)
+    (0...4).each_with_object(Array.new(4)) do |i, result|
+      result[3 - i] = rgba & 0xff
+      rgba >>= 8
+    end
+  end
+
+  def self.from_gosu(gosu_color)
+    color = allocate
+    color.gosu_color = gosu_color
+    color
+  end
+end

data/lib/rgss3/container.rb

@@ -0,0 +1,42 @@
+
+module RGSS3
+  # common methods for Plane, Sprite and Window
+  module Container
+
+    attr_reader :opacity
+    attr_accessor :z, :ox, :oy
+    attr_accessor :viewport, :visible
+    attr_accessor :tone
+
+    def initialize
+      @visible = true
+      @z = 0
+      @ox = 0
+      @oy = 0
+      @opacity = 255
+      Graphics.add_container(self)
+    end
+
+    def initialize_copy
+      copy = super
+      Graphics.add_container(copy)
+      copy
+    end
+
+    def dispose
+      @disposed = true
+      Graphics.remove_container(self)
+    end
+
+    def disposed?
+      @disposed
+    end
+
+    def opacity=(int)
+      @opacity = [[int, 255].min, 0].max
+    end
+
+    def draw
+    end
+  end
+end

data/lib/rgss3/font.rb

@@ -0,0 +1,50 @@
+class Font
+  
+  class << self
+    
+    attr_accessor :default_name, :default_size, :default_bold
+    attr_accessor :default_italic, :default_shadow, :default_outline
+    attr_accessor :default_color, :default_out_color
+    
+    def exist?(name)
+      f = (Gosu::Font.new(Graphics.gosu_window, "./Fonts/#{name}.ttf", 8) rescue false)
+      Gosu::Font.new(Graphics.gosu_window, name, 8) unless f
+      return true
+    rescue
+      return false
+    end
+  end
+  
+  self.default_name = ["Verdana", "Arial", "Courier New"]
+  self.default_size = 24
+  self.default_bold = false
+  self.default_italic = false
+  self.default_shadow = false
+  self.default_outline = true
+  self.default_color = Color.new(255, 255, 255, 255)
+  self.default_out_color = Color.new(0, 0, 0, 128)
+  
+  attr_accessor :name, :size, :bold, :italic, :shadow, :outline, :color, :out_color
+  
+  def initialize(name = Font.default_name, size = Font.default_size)
+    @name = name.dup
+    @size = size
+    @bold = Font.default_bold
+    @italic = Font.default_italic
+    @shadow = Font.default_shadow
+    @outline = Font.default_outline
+    @color = Font.default_color.dup
+    @out_color = Font.default_out_color.dup
+  end
+  
+  # NEW
+  
+  def first_existant_name
+    if @name.is_a?(Array)
+      @name.each {|a| return a if Font.exist?(a) }
+    else
+      return @name if Font.exist?(@name)
+    end
+    return "Verdana"
+  end
+end

data/lib/rgss3/game_window.rb

@@ -0,0 +1,21 @@
+module RGSS3
+  class GameWindow < Gosu::Window
+    attr_reader :frame_rate
+    def initialize(width: 544, height: 416, full_screen: false, frame_rate: 60, title: "Game")
+      @frame_rate = frame_rate
+      super(width, height, full_screen, 1000.0 / frame_rate)
+      self.caption = title
+    end
+
+    def update
+      fiber = RGSS3.fiber
+      if fiber
+        fiber.alive? ? fiber.resume : close
+      end
+    end
+
+    def draw
+      Graphics.draw
+    end
+  end
+end

data/lib/rgss3/graphics.rb

@@ -0,0 +1,137 @@
+
+require 'set'
+module Graphics
+
+  class << self
+
+    attr_accessor :frame_count
+    attr_reader :gosu_window
+    attr_reader :brightness, :frame_rate
+
+    def gosu_window
+      RGSS3.window
+    end
+
+    def frame_rate
+      RGSS3.window.frame_rate
+    end
+
+    def brightness=(int)
+      @brightness = [[255, int].min, 0].max
+      @draw_color.alpha = 255 - @brightness
+    end
+
+    def frame_rate=(int)
+      # @frame_rate = [[120, int].min, 10].max
+      #reform_window(width, height, fullscreen?, 1.0 / @frame_rate * 1000)
+    end
+  end
+
+  @brightness = 255
+  @frame_count = 0
+  @frozen = false
+  @draw_color = Gosu::Color.rgba(255, 255, 255, 0)
+  # @draw_color.saturation = 0
+  # @draw_color.alpha = 0
+  @containers = Set.new
+
+  def self.update
+    window = RGSS3.window
+    @current = window.record(window.width, window.height) do
+      @containers.each(&:draw)
+    end
+    @frame_count += 1
+    @latest = @current unless @frozen
+    Fiber.yield
+  end
+
+  def self.wait(duration)
+    duration.times { update }
+  end
+
+  def self.fadeout(duration)
+    # Thread.new {
+    #   rate = @brightness / duration.to_f
+    #   until @brightness <= 0
+    #     self.brightness -= rate
+    #     sleep 1.0 / frame_rate
+    #   end
+    #   self.brightness = 0
+    # }
+  end
+
+  def self.fadein(duration)
+    # Thread.new {
+    #   rate = 255 / duration.to_f
+    #   until @brightness >= 255
+    #     self.brightness += rate
+    #     sleep 1.0 / frame_rate
+    #   end
+    #   self.brightness = 255
+    # }
+  end
+
+  def self.freeze
+    @frozen = true
+  end
+
+  def self.transition(duration = 10, filename = "", vague = 40)
+    @frozen = false
+    # VAGUE ELUDES ME AS TO HOW TO INTEGRATE
+  end
+
+  def self.snap_to_bitmap
+    Bitmap.from_gosu(@current)
+  end
+
+  def self.frame_reset
+    # AT A LOSS ON HOW TO INTEGRATE
+  end
+
+  def self.width
+    RGSS3.window.width
+  end
+
+  def self.height
+    RGSS3.window.height
+  end
+
+  def self.resize_screen(w, h)
+    reform_window(w, h, fullscreen?, RGSS3.update_interval)
+  end
+
+  def self.play_movie(filename)
+    # LIKELY TO REMAIN UNINTEGRATED
+  end
+
+  def self.add_container(container)
+    @containers.add(container)
+  end
+
+  def self.remove_container(container)
+    @containers.delete(container)
+  end
+
+  def self.fullscreen?
+    RGSS3.window.fullscreen?
+  end
+
+  def self.draw
+    if @latest
+      @latest.draw(0, 0, 0)
+      c = @draw_color
+      RGSS3.window.draw_quad(0, 0, c, 0, height, c, width, 0, c, width, height, c, 1)
+    end
+  end
+
+  # def self.set_fullscreen(bool)
+  #   return if bool == fullscreen?
+  #   reform_window(width, height, bool, gosu_window.update_interval)
+  # end
+
+  def self.reform_window(w, h, f, update_interval)
+    # Graphics.gosu_window.close
+    # Graphics.gosu_window = GosuGame.new(w, h, f, update_interval)
+    # Graphics.gosu_window.show
+  end
+end

data/lib/rgss3/input.rb

@@ -0,0 +1,159 @@
+
+# Usage:
+# Input.trigger?(2)
+# Input.trigger?(:DOWN)
+# Input.trigger?(Input::KB_DOWN)
+# Input.trigger?(Input::Key[Gosu::KB_DOWN])
+module Input
+
+  include Gosu
+
+  KEY_TO_INT = {
+    DOWN: 2,
+    LEFT: 4,
+    RIGHT: 6,
+    UP: 8,
+
+    A: 11,
+    B: 12,
+    C: 13,
+    X: 14,
+    Y: 15,
+    Z: 16,
+    L: 17,
+    R:  18,
+
+    SHIFT: 21,
+    CTRL: 22,
+    ALT: 23,
+
+    F5: 25,
+    F6: 26,
+    F7: 27,
+    F8: 28,
+    F9: 29
+  }
+
+  KEY_TO_INT_PROC = KEY_TO_INT.to_proc
+
+  KEY_TO_INT.each_key do |sym|
+    const_set sym, sym
+  end
+
+  KEY_MAPPER = {
+    KB_ENTER => C,
+    KB_LEFT_SHIFT => [SHIFT, A],
+    KB_RIGHT_SHIFT => [SHIFT, A],
+    KB_LEFT_CONTROL => CTRL,
+    KB_RIGHT_CONTROL => CTRL,
+    KB_LEFT_ALT => ALT,
+    KB_RIGHT_ALT => ALT,
+    KB_SPACE => C,
+    KB_ESCAPE => B,
+    KB_DOWN => DOWN,
+    KB_LEFT => LEFT,
+    KB_RIGHT => RIGHT,
+    KB_UP => UP,
+    KB_INSERT => B,
+    KB_NUMPAD_0 => B,
+    KB_NUMPAD_2 => DOWN,
+    KB_NUMPAD_4 => LEFT,
+    KB_NUMPAD_6 => RIGHT,
+    KB_NUMPAD_8 => UP,
+    KB_F5 => F5,
+    KB_F6 => F6,
+    KB_F7 => F7,
+    KB_F8 => F8,
+    KB_F9 => F9,
+    KB_Z => C,
+    KB_X => B,
+    KB_A => X,
+    KB_S => Y,
+    KB_D => Z,
+    KB_Q => L,
+    KB_W => R
+  }.freeze
+
+  REVERSE_KEY_MAPPER = {}
+
+  KEY_MAPPER.each do |kb_key, syms|
+    keys = Array(syms).map(&KEY_TO_INT_PROC)
+    keys.each do |key|
+      REVERSE_KEY_MAPPER[key] ||= []
+      REVERSE_KEY_MAPPER[key].push(kb_key)
+    end
+  end
+
+  REVERSE_KEY_MAPPER.freeze
+
+  # A wrapper for Gosu::KB_****
+  # can be used as argument for methods in Input
+  Key = Struct.new(:kb_key)
+
+  Gosu.constants.each do |sym|
+    if sym[0, 3] == :KB_
+      kb_key = Gosu.const_get(sym)
+      const_set sym, Key[kb_key].freeze
+    end
+  end
+
+  # stores pressed times of each key
+  @states = Hash.new { |h, k| h[k] = 0 }
+  @dir_4_8 = [5, 5]
+
+  def self.update
+    @states.each_key do |kb_key|
+      @states[kb_key] = RGSS3.window.button_down?(kb_key) ? @states[kb_key] + 1 : 0
+    end
+    @dir_4_8 = calculate_dir_4_8
+  end
+
+  def self.trigger?(key)
+    presstime?(key) { |t| t == 1 }
+  end
+
+  def self.press?(key)
+    presstime?(key, &:positive?)
+  end
+
+  def self.repeat?(key)
+    presstime?(key) { |t| t == 1 || t > 23 && t % 6 == 0 }
+  end
+
+  def self.dir4
+    @dir_4_8[0]
+  end
+
+  def self.dir8
+    @dir_4_8[1]
+  end
+
+  private
+
+  def self.presstime?(arg)
+    arg = KEY_TO_INT[arg] if arg.is_a?(Symbol)
+    arg = REVERSE_KEY_MAPPER[arg] if arg.is_a?(Integer)
+    arg = [arg.kb_key] if arg.is_a?(Key)
+    return false unless arg
+    arg.any? { |kb_key| yield @states[kb_key] }
+  end
+
+  def self.calculate_dir_4_8
+    min_presstime = Float::INFINITY
+    dir4 = 5
+    dir8 = [2, 4, 6, 8].inject(5) do |dir, dir_checking|
+      presstime = REVERSE_KEY_MAPPER[dir_checking].map(&@states).select(&:positive?).min
+      if presstime
+        if presstime < min_presstime
+          dir4 = dir_checking
+          presstime = min_presstime
+        end
+        dir + dir_checking - 5
+      else
+        dir
+      end
+    end
+    return dir8, dir8 if [2, 4, 5, 6, 8].include?(dir8)
+    return dir4, dir8
+  end
+end