stylet 0.0.1

data/lib/stylet/contrib/shared_pad.rb

@@ -0,0 +1,32 @@
+# すべてのジョイスティックに反応
+
+require "stylet"
+
+module Stylet
+  module Input
+    class SharedPad
+      include Base
+      include ExtensionButton
+      include StandardKeybordBind
+      include HjklKeyboardBind
+      include JoystickBindMethod
+
+      def key_bit_update_all(*)
+        super
+        Stylet::Base.active_frame.joys.each do |joy|
+          bit_update_by_joy(joy)
+        end
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  require_relative "../../stylet"
+  shared_pad = Stylet::Input::SharedPad.new
+  Stylet.run {
+    shared_pad.key_bit_update_all
+    shared_pad.key_counter_update_all
+    vputs shared_pad
+  }
+end

data/lib/stylet/contrib/sprity.rb

@@ -0,0 +1,149 @@
+# マップチップと単一画像の違いを吸収してキャラクタを表示する
+#
+# ▼スプライトの登録と描画
+#
+#   Sprity::ImageFile.memory_record_reset [
+#     {:key => :foo, :filename => "assets/images/foo.png"},
+#   ]
+#
+#   screen.put(Sprity::Sprite[:foo].surface, 0, 0)
+#
+# ▼内部で保持している surface をすべて解放
+#
+#   Stylet::Sprity.surface_destroy_all
+#
+# ▼ :filename の指定がシンボルなら ImageFile から取得し、文字列ならそのパスから読み出す
+#
+#   {:key => :mario, :filename => :maptip}           ← 主に一つの画像にキャラがたくさん入っている時用でサーフェイスを共有する
+#   {:key => :mario, :filename => "background.png"}  ← 一つの画像とする
+#
+# ▼マップチップから指定の部分を刳り貫く 16 x 16 と考えて 2, 3 の部分から 16 x 16 で刳り貫く
+#
+#   {:cliping => [16 * 2, 16 * 3, 16, 16]}
+#
+# ▼マップチップから指定の部分を刳り貫いたあと 32 x 32 に拡大して、余白を抜き色にする
+#
+#   {:cliping => [...], :transform => {:wh => [32, 32], :mask => true}}
+#
+# ▼回転する
+#
+#   {:transform => {:angle => 45}}
+#
+# ▼ ([0, 0, 255] の色を 0.5 だけ掛け合わせる (mixの値を配列にすると実行を繰り返す)
+#
+#   {:transform => {:mix => {:rgb => [0, 0, 255], :alpha => 128}}}
+#
+
+module Stylet
+  module Sprity
+    class << self
+      def surface_destroy_all
+        [ImageFile, Sprite].each(&:surface_destroy_all)
+      end
+
+      def processing(surface, params)
+        if params[:cliping]
+          surface = surface.copy_rect(*params[:cliping])
+        end
+        if params[:transform]
+          surface = transform(surface, params[:transform])
+        end
+        surface
+      end
+
+      def load_file(filename, mask: false)
+        surface = SDL::Surface.load(filename)
+        if mask
+          surface.set_color_key(SDL::SRCCOLORKEY, 0)
+        end
+        surface.display_format
+      end
+
+      private
+
+      def transform(surface, params)
+        w, h = params[:wh] || [surface.w, surface.h]
+        s = surface.transform_surface(
+          0,                      # bg_color
+          params[:angle] || 0,    # 角度
+          w.to_f / surface.w,     # x倍率
+          h.to_f / surface.h,     # y倍率
+          0)                      # flags
+
+        Array.wrap(params[:mix]).each do |mix|
+          s.draw_rect(0, 0, s.w, s.h, mix[:rgb], true, mix[:alpha])
+        end
+
+        if params[:mask]
+          s.set_color_key(SDL::SRCCOLORKEY, 0)
+        end
+
+        s.display_format
+      end
+    end
+
+    module SurfaceShare
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      class_methods do
+        def surface_destroy_all
+          each(&:surface_destroy)
+        end
+      end
+
+      def surface_destroy
+        if @surface
+          unless @surface.destroyed?
+            @surface.destroy
+          end
+          @surface = nil
+        end
+      end
+
+      def surface
+        @surface ||= _surface
+      end
+    end
+
+    class ImageFile
+      include SurfaceShare
+
+      include MemoryRecord
+      memory_record []
+
+      private
+
+      def _surface
+        Sprity.load_file(@attributes[:filename], mask: @attributes[:mask])
+      end
+    end
+
+    class Sprite
+      include SurfaceShare
+
+      include Stylet::Delegators
+
+      include MemoryRecord
+      memory_record []
+
+      def swh
+        @swh ||= vec2[surface.w, surface.h]
+      end
+
+      private
+
+      def _surface
+        key = @attributes[:filename]
+        if key.kind_of? Symbol
+          s = ImageFile[key].surface
+        else
+          s = Sprity.load_file(key, mask: @attributes[:mask])
+        end
+        Sprity.processing(s, @attributes)
+      end
+    end
+  end
+end

data/lib/stylet/core.rb

@@ -0,0 +1,118 @@
+module Stylet
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      include Singleton
+
+      cattr_accessor :_active_instance
+    end
+
+    class_methods do
+      # run{|win| win.vputs 'Hello' }
+      # run{ vputs 'Hello' }
+      def run(*args, &block)
+        active_frame.run(*args, &block)
+      end
+
+      # run_initializers 実行済みの active_frame
+      def active_frame
+        @active_frame ||= active_instance.tap(&:run_initializers)
+      end
+
+      # すでにどこかで実行済みの場合は instance ではなく
+      # 先に実行された _active_instance の方を返す
+      # これで何度も初期化したり _active_instance が上書きされることがなくなる
+      def active_instance
+        @active_instance ||= _active_instance || instance
+      end
+    end
+
+    def initialize
+      raise "Singletonなのに再び初期化されている。ということは Stylet::Base を継承したクラスを複数作っている可能性があります。" if _active_instance
+      self._active_instance = self
+      @init_code = 0
+      @initialized = []
+    end
+
+    def logger
+      Stylet.logger
+    end
+
+    def run_initializers
+      init_on(:core) do
+        SDL.init(SDL::INIT_VIDEO)
+      end
+    end
+
+    def setup
+    end
+
+    def polling
+    end
+
+    def before_update
+    end
+
+    def update
+    end
+
+    def screen_flip
+    end
+
+    def after_run
+    end
+
+    def run(title: nil, &block)
+      self.title = title
+      run_initializers          # SDL.init(@init_code)
+      setup                     # for user
+      main_loop(&block)
+    ensure
+      after_run
+    end
+
+    def main_loop(&block)
+      catch :exit do
+        loop do
+          next_frame(&block)
+        end
+      end
+    end
+
+    def next_frame(&block)
+      raise "SDL is not initialized" if @initialized.empty?
+      polling
+      if pause? || !screen_active
+        return
+      end
+      screen_flip               # @screen.flip
+      before_draw               # @console_current_line = 0
+      background_clear
+      before_update             # vputs(system_infos)
+
+      # ここからユーザーの処理
+      # ということは next_frame の中のブロックから呼ぶ必要はない？
+
+      update                    # for user
+
+      if block_given?
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+    end
+
+    private
+
+    def init_on(key)
+      unless @initialized.include?(key)
+        yield
+        @initialized << key
+        logger.debug "init: #{key}"
+      end
+    end
+  end
+end

data/lib/stylet/cpu_stat.rb

@@ -0,0 +1,58 @@
+require "benchmark"
+require "active_support/core_ext/benchmark"
+
+module Stylet
+  # CPU率の測定
+  #
+  #   * 余力とCPUは反比例の関係
+  #   * なので余力を測定することでCPU率を得られる
+  #   * 1フレーム毎に計算すると誤差が大きいため1秒毎に計算
+  #
+  # Example:
+  #
+  #   stat = CpuStat.new
+  #   loop do
+  #     stat.benchmark { screen.flip }       # 余力測定
+  #     stat.cpu_ratio # => 80.0
+  #   end
+  #
+  # CPU率の求め方
+  #
+  #    flip   余力    CPU
+  #   -------------------
+  #   16 ms   100 %    0%
+  #   15 ms    90 %   10%
+  #    1 ms    10 %   90%
+  #    0 ms     0 %  100%
+  #
+  #   free =       ms  / 16 * 100
+  #   cpu  = (16 - ms) / 16 * 100
+  #
+  # 1秒単位で測定すれば / 16 は不要になる
+  class CpuStat
+    def initialize
+      @free_ms = 1000.0
+
+      @old_time = SDL.get_ticks
+      @total_ms = 0
+    end
+
+    def benchmark
+      @total_ms += Benchmark.ms { yield }
+      now = SDL.get_ticks
+      if now >= @old_time + 1000.0
+        @old_time = now
+        @free_ms = @total_ms
+        @total_ms = 0
+      end
+    end
+
+    def cpu_ms
+      1000.0 - @free_ms
+    end
+
+    def cpu_ratio
+      cpu_ms * 100.0 / 1000.0
+    end
+  end
+end

data/lib/stylet/delegators.rb

@@ -0,0 +1,54 @@
+require "active_support/concern"
+require "active_support/core_ext/module/delegation"
+
+module Stylet
+  module Delegators
+    extend ActiveSupport::Concern
+
+    included do
+      unless self <= Base
+        delegate *[
+          :vputs,
+          :vputs_vector,
+          :dputs,
+          :srect,
+          :frame_counter,
+          :joys,
+
+          :draw_dot,
+          :draw_line,
+          :draw_circle,
+          :draw_triangle,
+          :draw_square,
+          :draw_angle_rect,
+          :draw_rect,
+          :draw_rect4,
+          :draw_vector,
+          :draw_arrow,
+          :draw_polygon,
+
+          :screen,
+          :system_font,
+
+          :fps_stat,
+          :cpu_stat,
+
+          :vec2,
+          :vec3,
+          :rect2,
+          :rect4,
+        ], :to => "Stylet::Base.active_frame"
+      end
+
+      delegate(*[:rsin, :rcos], :to => "Stylet::Magic")
+    end
+  end
+end
+
+if $0 == __FILE__
+  require_relative "../stylet"
+  class App < Stylet::Base
+    update { Class.new { include Stylet::Delegators }.new.vputs "ok" }
+    run
+  end
+end

data/lib/stylet/draw.rb

@@ -0,0 +1,256 @@
+# SDL描画関連
+
+module Stylet
+  module Draw
+    attr_reader :frame_counter, :sdl_event, :srect, :screen, :screen_active
+    attr_reader :fps_stat, :cpu_stat
+    attr_accessor :title
+
+    def run_initializers
+      super
+      init_on(:draw) do
+        @frame_counter = 0
+        @fps_adjust = FpsAdjust.new
+        @fps_stat = FpsStat.new
+        @cpu_stat = CpuStat.new
+        @screen_active = true
+
+        screen_open
+        screen_info_check
+
+        if Stylet.config.hide_mouse
+          SDL::Mouse.hide
+        end
+
+        if @title
+          self.title = @title
+        end
+      end
+    end
+
+    # ハードウェアがダブルバッファ対応の場合flipで自動的にVSYNCを待って切り替えるため
+    # ハードウェアのフレーム数(60FPS)以上にはならない
+    def screen_flip
+      super
+      @fps_adjust.delay
+      @fps_stat.update
+      @cpu_stat.benchmark { @screen.flip }
+      @frame_counter += 1
+    end
+
+    def after_run
+      super
+      screen_destroy
+      backgroud_image_destroy
+    end
+
+    def title=(str)
+      if str
+        if @title != str
+          @title = str
+          if @screen
+            SDL::WM.set_caption(@title.to_s, @title.to_s)
+          end
+        end
+      end
+    end
+
+    def polling
+      super
+      case @sdl_event = SDL::Event.poll
+      when SDL::Event::KeyDown
+        if @sdl_event.sym == SDL::Key::ESCAPE || @sdl_event.sym == SDL::Key::Q
+          throw :exit, :break
+        end
+        if @sdl_event.sym == SDL::Key::K1
+          full_screen_toggle
+        end
+      when SDL::Event::Active
+        if (@sdl_event.state & SDL::Event::APPINPUTFOCUS).nonzero?
+          @screen_active = @sdl_event.gain
+        end
+      when SDL::Event::VideoResize
+        screen_resize(@sdl_event.w, @sdl_event.h)
+      when SDL::Event::Quit
+        throw :exit, :break
+      end
+    end
+
+    def key_down?(sym)
+      if @sdl_event.is_a? SDL::Event::KeyDown
+        @sdl_event.sym == sym
+      end
+    end
+
+    def __draw_line(x0, y0, x1, y1, color)
+      @screen.draw_line(x0, y0, x1, y1, Palette.fetch(color))
+    end
+
+    # draw_rect の場合、デフォルトだと幅+1ドット描画されるため -1 してある
+    # draw_rect(0, 0, 0, 0) で 1 ドット表示されてしまう
+    #
+    def draw_rect4(x, y, w, h, color: :foreground, fill: false, alpha: nil, surface: @screen)
+      return if w.zero? || h.zero?
+      color = Palette.fetch(color)
+      # raise "w, h は正を指定するように" if w < 0 || h < 0
+      if fill
+        if alpha
+          surface.draw_rect(x, y, w.abs - 1, h.abs - 1, color, true, alpha)
+        else
+          surface.fill_rect(x, y, w.abs, h.abs, color)
+        end
+      else
+        surface.draw_rect(x, y, w.abs - 1, h.abs - 1, color, false, alpha)
+      end
+    end
+
+    def draw_line(p0, p1, **options)
+      options = {
+        :color => :foreground,
+      }.merge(options)
+      @screen.draw_line(p0.x, p0.y, p1.x, p1.y, Palette.fetch(options[:color]))
+    rescue RangeError => error
+      # warn [p0, p1].inspect
+      # raise error
+    end
+
+    def draw_dot(p0, **options)
+      draw_line(p0, p0, options)
+    end
+
+    def draw_rect(rect, **options)
+      draw_rect4(*rect, options)
+    end
+
+    def save_bmp(fname)
+      @screen.save_bmp(fname)
+    end
+
+    def system_infos
+      list = [
+        @frame_counter,
+        "FPS:#{@fps_stat.fps}",
+        "CPU:#{format("%4.2f", @cpu_stat.cpu_ratio)}",
+      ]
+      if Stylet.production
+      else
+        list += [
+          "SE:#{SDL::Mixer.playing_channels}/#{SE.allocated_channels}",
+          "M#{SDL::Mixer.play_music? ? 1 : 0}",
+          "#{@srect.w}x#{@srect.h}",
+          app_state,
+        ]
+      end
+      list
+    end
+
+    def before_update
+      super
+      # return if Stylet.production
+      vputs system_infos.compact.join(" ")
+    end
+
+    def full_screen_toggle
+      Stylet.config.full_screen = !Stylet.config.full_screen
+      screen_open
+    end
+
+    def screen_resize(w, h)
+      Stylet.config.screen_size = [w, h]
+      screen_open
+    end
+
+    private
+
+    def screen_open
+      screen_destroy    # 既存サーフェスを破棄しないとGCの際に落ちる
+      @screen = SDL::Screen.open(*Stylet.config.screen_size, Stylet.config.color_depth, screen_flags)
+      @srect = Rect2.new(@screen.w, @screen.h)
+    end
+
+    def screen_destroy
+      if @screen
+        unless @screen.destroyed?
+          @screen.destroy
+        end
+        @screen = nil
+      end
+    end
+
+    def screen_flags
+      flags = Stylet.config.screen_flags
+      flags |= SDL::FULLSCREEN if Stylet.config.full_screen
+      flags
+    end
+
+    def screen_info_check
+      logger.debug "SGE: #{SDL.respond_to?(:auto_lock).inspect}"
+
+      # フルスクリーンで利用可能なサイズ
+      logger.debug "SDL::Screen.list_modes # => #{SDL::Screen.list_modes(SDL::FULLSCREEN | SDL::HWSURFACE).inspect}"
+
+      # 画面情報
+      logger.debug "SDL::Screen.info # => #{SDL::Screen.info.inspect}"
+    end
+
+    def app_state
+      app_state_list = {
+        SDL::Event::APPMOUSEFOCUS => "M",
+        SDL::Event::APPINPUTFOCUS => "K",
+        SDL::Event::APPACTIVE     => "A",
+      }
+      app_state_list.collect { |k, v|
+        if (SDL::Event.app_state & k).nonzero?
+          v
+        end
+      }.join
+    end
+
+    # オーバーライド推奨
+    def background_clear
+      simple_background_clear
+    end
+
+    def simple_background_clear
+      draw_rect(@srect, :color => :background, :fill => true)
+    end
+  end
+
+  concern :DeprecateBackground do
+    def screen_open
+      super
+
+      @backgroud_image ||= background_image_load
+    end
+
+    def background_clear
+      if @backgroud_image
+        SDL::Surface.blit(@backgroud_image, @srect.x, @srect.y, @srect.w, @srect.h, @screen, 0, 0)
+      else
+        super
+      end
+    end
+
+    def background_image_load
+      if v = Stylet.config.background_image
+        file = Pathname(v)
+        if file.exist?
+          bin = SDL::Surface.load(file.to_s)
+          bin.display_format
+        end
+      end
+    end
+
+    def backgroud_image_destroy
+      if @backgroud_image
+        @backgroud_image.destroy
+        @backgroud_image = nil
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  require_relative "../stylet"
+  Stylet.run
+end