RGSS3Facets 0.02

2014 年 2 月 23 日

0.02

Class:
#基于类的通用cache系统，比如
x = Bitmap.cache(“Graphics/Parallaxes/Mountain4”) #你懂的
y = Bitmap.cache(“Graphics/Parallaxes/Mountain4”)
# x.object_id == y.object_id应该成立，同一个位图
#Bitmap.clear_cache #你懂的
#也可以是自定义对象
class A
def initialize(a, b)
@a, @b = a, b
end
end
x = A.cache(3, 5)
y = A.cache(3, 5)
#应该是同一个对象

# RGSS3Facets::CachePolicy 奇怪的东西：
Bitmap.cache_policy = RGSS3Facets::CachePolicy::Default #Cache在内存中，以Hash的形式记录，类似于默认脚本的Cache或者RPG::Cache
Bitmap.cache_policy = RGSS3Facets::CachePolicy::Marshal.new(Bitmap) #Cache不是在内存中而是以Marshal形式存到磁盘上
Bitmap.cache_policy = RGSS3Facets::CachePolicy::BareMarshal.new(Bitmap) #Cache不是在内存中而是以Marshal形式存到磁盘上，而且没有Marshal头，仅仅是直接调用了_dump和_load

Bitmap:
#Bitmap::MarshalPolicy bitmap的marshal方案可以是
Bitmap::MarshalPolicy = Bitmap::BitmapMarshalPolicy::Raw # [width, height, data].pack(“LLa*”)
Bitmap::MarshalPolicy = Bitmap::BitmapMarshalPolicy::RawCompress # [width, height, Zlib::Deflate.deflate(data)].pack(“LLa*”)
Bitmap::MarshalPolicy = Bitmap::BitmapMarshalPolicy::BitmapFile # Marshal内容相当于savebmp做的，也就是一个合法的bmp文件内容

Object:
load_script(name) #也就是eval read_data(name), TOPLEVEL_BINDING, “Load Script: #{name}”, 1

0.01

Object:
font.assign(:size=>5, :color=>Color.new(255,0,0,255)) # font.size=5; font.color = Color.new(255,0,0,255)
object.self # 返回本身，为了某些场合可以用&:self
object.deepcopy #=>某种深拷贝，也就是Marshal.load Marshal.dump object
object.template(“{{a}}, {{b}}”)#=>模板替换，也就相当于是”#{obj.a},#{obj.b}”，但模板内容可以是变量。
私有:
read_data(“Data/1.txt”) #=>读取Data/1.txt的内容，可以是加密包中的内容
write_data(“Data/1.txt”, “Hello”)#=>把Hello写到Data/1.txt，只能是磁盘上的，不会变更加密包
sugar(/\b类\b/){“class”} #=>宏替换，$RGSS_SCRIPTS.each{|x| x[3].gsub!(/\b类\b/){“class”}}
with(obj){}#=>obj.instance_eval{}
a = 5
ref{}[“a”]=3
a = ref{}[“a”]#=> 上下文变量的字符引用

Module:
Sprite_Base.each_object{|x| p x}#遍历Sprite_Base的实例
Vocab.each_constant{|value, name| p value, name}#遍历常量，以值和名的形式
MyModule.to_class #生成一个include了本模块的类（可以new了）
attr_constant :a, 5# 相当于def a(); 5; end

Proc:
lambda{|x| a}.call(a,b,c)可以写成lambda{|x| a}.update(a,b,c) lambda{|x| a}.fire(a,b,c)随便什么方法名都行
用method_missing实现的，不一定是call了

Range:
(1..5).clamp(a) # 如果a<1返回1 如果a>5返回5 否则返回a

Rect:
rect.each_slice(5, 5) do |r| … end # 将这个rect均匀分成5×5的部分，每一部分调用一下迭代器

Exception:
ex.raise # reraise ex
ex.translate(新的消息) # 返回一个和ex只有消息不同的异常对象，也就是ex.exception的别名

IO:
IO.binread(“1.txt”) #二进制读取1.txt
IO.binwrite(“1.txt”, “Hello”)#二进制写入1.txt

Symbol:
to_proc(这个功能VA本来就有)

String:
self.note.match_notes “<itemid = {{item}}>”, “<skillid = {{skill}}>”#如果self.note是一个”<itemid = 5> <skillid = 3>”的话，返回一个hash {“item”=>5, “skill”=>3}

Bitmap:
bitmap.repeat_blt(bitmap.rect, another_bitmap, another_bitmap.rect)#尽可能平铺绘制another_bitmap的rect部分的内容
bitmap.address:位图地址
bitmap.savebmp(“1.bmp”): 以bmp格式保存为1.bmp
bitmap.savepng(“1.png”):以png格式保存为1.png
bitmap.getBitmap(rect) : 返回rect部分构成的新位图
bitmap.split(:A=>[0,0,128,128], :B=>[0,128,128,128]):返回一个hash，其中hash[:A]= bitmap.getBitmap(Rect.new(0,0,128,128))，类推
bitmap.with_tone!(tone)
bitmap.with_tone(tone) #用指定的色调tone来处理本位图

(下面是还在测试和修正的内容）
Sprite:
sprite.image #返回sprite能看到的图形，没有考虑tone，wave系列,考虑了src_rect
Plane:
plane.image #返回plane能看到的图形，没有考虑tone，考虑了屏幕大小和循环的情况

# http://seiran.mist.so

# mixin in to Kernel (Object)
module RGSS3Facets
  module RGSS
    Sprite   = ::Sprite
    Bitmap   = ::Bitmap
    Rect     = ::Rect
    Plane    = ::Plane
    Viewport = ::Viewport
    Tilemap  = ::Tilemap
  end

  class CPtr
    RMM = Win32API.new("Kernel32", "RtlMoveMemory", "LLL", "L")
    SLEN = Win32API.new("Kernel32", "lstrlenA", "L", "L")
    WLEN = Win32API.new("Kernel32", "lstrlenW", "L", "L")
    def initialize(start, len = 0)
      @start, @len = start, len
    end
    def [](st, le = nil)
      if !le
        CPtr.new(self[st * 4, 4].unpack("L").first)
      else
        buf = ""*le
        RMM.call *[buf, @start+st, le].pack("pLL").unpack("L*")
        buf = buf.force_encoding("US-ASCII") if buf.respond_to?(:force_encoding)
        buf
      end
    end
    def +(a)
      CPtr.new(@start+a, @len)
    end
    def []=(st, le, str)
      RMM.call *[@start+st, str, [le,str.size].min].pack("LpL").unpack("L*")
    end
    def to_s(size = nil)
      a = SLEN.call(to_i) 
      size ||= a
      self[0, [size, a].min]
    end
    def to_ws(size = nil)
      a = WLEN.call(to_i) 
      size ||= a
      self[0, [size, a].min * 2]
    end
    def to_i
      @start
    end
  end

  module Object
    public 
    def assign(hash)
      hash.each{|k, v|send "#{k}=", v}
      self
    end

    def self
      self
    end

    def identity
      lambda{|x| x}
    end

    def send_rescue(*a, &b)
      send *a rescue b.call
    end

    # [1,2,3,4,5].select(&true) 
    # 真是一点用都没有啊。。。
    def to_proc
      proc{ self }
    end

    def deepcopy
      Marshal.dump Marshal.load self  
    end

    def template(str, lb = "{{", rb = "}}")
      regexp = Regexp.new(Regexp.escape(lb) + "(.*?)" + Regexp.escape(rb))
      str.gsub(regexp) do send $1 end
    end

    def grep_var(cond)
      instance_variables.select{|x| cond === x}.each{|y| yield(instance_variable_get(y), y)}
    end

    def call_each(method, *args)
      args.each{|x|
        send method, *args
      }
    end

    private
    def weaken(a = StandardError)
      yield
    rescue a => ex
       raise
    rescue Exception => ex
        raise StandardError, ex.message, ex.backtrace
    ensure
        $@.slice!(0, 2) if $@ 
    end

    class NoException < StandardError; end
    class CallerHint < NoException; end

    def hint(array)
      raise CallerHint, "No Exception", array
    end

    def reraise(ex)
       raise ex.class, ex.message, ex.backtrace
    end

    def using(*a)
      yield
      a.reverse.each(&:dispose)
    end

    def write_data(name, *content)
      File.open(name, 'wb') do |f| content.each do |x| f.write x end end
    end

    def load_script(name)
      eval read_data(name), TOPLEVEL_BINDING, "Load Script: #{name}", 1
    end

    def read_data(name)
       begin
        File.open(name, 'rb') do |f| f.read end
      rescue Exception
          x = Marshal.method(:load)
          y = class << Marshal; self; end
          y.send(:define_method, :load){|a, *b| a.respond_to?(:read) ? a.read : a.to_s}
          ret = load_data(name)
          y.send(:define_method, :load, x)
          ret
       end
    end

    def sugar(regexp)
      $RGSS_SCRIPTS.each{|x| x[3] = x[3].gsub(regexp){ yield($~) } }
    end

    def with(obj, &a)
      obj.instance_eval &a
    end

    class Ref
      def initialize(binding = nil)
        @binding = binding || TOPLEVEL_BINDING
      end
      def [](text)
        eval(text, @binding)
      end
      def []=(text, obj)
        eval "#{text} = ObjectSpace._id2ref(#{obj.object_id})", @binding
      end
    end

    def ref(&b)
      Ref.new(b && b.binding)
    end
  end

  module Module
    def each_object
      ObjectSpace.each_object(self).each{|obj|
        yield obj
      }
    end

    def each_constant
      if block_given?
       constants.each{|x|
         yield const_get(x), x
       }
      else
       Hash[constants.map{|x| [x, const_get(x)]}]
      end
    end

    def to_class
      Class === self ? self : begin
        @_avatar ||= begin
          this = self
          Class.new do include this end
        end
      end
    end

    def attr_constant(sym, c)
      define_method(sym, lambda{c})
    end

    alias def_constant_method  attr_constant 
  end

  class FacadeClass
     def initialize(obj, *a)
       @obj  = obj
       @args = a  
     end
     def new(*a, &b)
       v = @obj.new(*a, &b)
       @args.each{|x| v = x.new(v)}
       v
     end
  end

  module CachePolicy
    class Default
      def initialize
        @cache = {}
      end
      def set_or_get(k)
        if has?(k)
          get(k)
        else
          set(k, yield)
        end
      end
      def set(k, v)
        @cache[k] = v
      end
      def get(k, v)
        @cache[k]
      end
      def remove(k)
        @cache.delete k
      end
      def has?(k)
        @cache.include?(k)
      end
      def clear
        @cache.each{|k, v| yield v, k} if block_given?
        @cache.clear
      end
    end

    class Marshal
      def initialize(klass)
        @klass = klass
        @base = "Data/Cache/#{encode_name klass}/"
        Dir.mkdir @base rescue 1
      end

      def set_or_get(k)
        if has?(k)
          get(k)
        else
          set(k, v = yield)
          v
        end
      end

      def encode_name(k)
        [::Marshal.dump(k)].pack("m").tr("\n+/", "_%$")
      end

      def filename(k)
        @base+encode_name(k)
      end

      def set(k, v)
        write_data filename(k), ::Marshal.dump(v)
      end

      def get(k)
        ::Marshal.load read_data filename(k)
      end

      def has?(k)
        FileTest.exist?(filename(k))
      end

    end

    class BareMarshal < Marshal
      def set(k, v)
        write_data filename(k), v._dump(0)
      end

      def get(k)
        @klass._load read_data filename(k)
      end
    end
  end

  module Class
    def [](*a)
      RGSS3Facets::FacadeClass.new(self, *a)
    end

    def cache_policy
      @cache_policy ||= CachePolicy::Default.new
    end

    def cache_policy=(obj)
      @cache_policy = obj
    end

    def c_new(*a, &b)
      cache_policy.set_or_get([a, b]){ new(*a, &b) }
    end

    alias cache c_new

    def c_clear
      cache_policy.clear do |x| x.dispose if x.respond_to?(:dispose) && !x.send_rescue(:disposed?){false} end
    end

    alias clear_cache c_clear
  end

  module Proc
    def method_missing(sym, *a, &b)
      call(*a, &b)
    end
  end

  module Range
    def clamp(val)
      [[first, val].max, exclude_end? ? last.succ : last].min
    end
  end

  module Rect
    def to_a
      [x, y, width, height]
    end

    def each_slice(div_x = 1, div_y = 1)
      cx, cy = width / div_x, height / div_y
      a = RGSS::Rect.new(0, 0, cx, cy)
      ny = y
      div_y.times{
        nx = x
        div_x.times{
          a.set(nx, ny, cx, cy)
          yield a
          nx += cx
        }
        ny += cy
      }
    end
  end

  module Binding
    def [](text)
       eval(text, self)
    end
    def []=(text, obj)
      eval "#{text} = ObjectSpace._id2ref(#{obj.object_id})", self
    end
  end

  module Exception
    def raise
      reraise self
    end
=begin
See what the doc said,
 exception([error_message]) 
 引数を指定しない場合は self を返します。
 そうでなければ、自身のコピーを生成し、message 属性を error_message にして返します。
 raise は、実質的に、例外オブジェクトの exception メソッドの呼び出しです。

 If no argument is given, return self.
 Otherwise, return a copy of self, with the message property changed to error_message
 actually 'raise' calls an Exception object's exception method.

 Because method 'exception' is actually a method to replace error message.
here I just rename it to translate
=end
    def translate(msg = nil)
      exception(msg || self.message)
    end

  end

  module IO_extend
    def binread(file)
      open(file, 'rb') do |f|
        f.read
      end
    end
    def binwrite(file, content)
      open(file, 'wb') do |f|
        f.write content
      end
    end
  end

  module RegExp
    def sub(str, *a, &b)
      str.sub(self, *a, &b)
    end
    def gsub(str, *a, &b)
      str.gsub(self, *a, &b)
    end
  end

  module Symbol
    def to_proc
      lambda{|*a| a.shift.send self, *a}
    end
  end

  module Comparable
    def min_with(obj)
      self < obj ? self : obj
    end
    def max_with(obj)
      self > obj ? self : obj
    end
  end

  module String
    def match_note(expr)
      a = Regexp.new expr.gsub(/\{\{(\S+)\}\}/){
        "(?<#$1>.*?)"
      }
      self =~ a
      $~
    end

    def match_notes(*args)
      ret = {}
      args.each{|x|
        v = match_note(x)
        v.names.each do |k|
          ret[k] = v[k]
        end
      }
      ret
    end
  end

  module Bitmap
    def repeat_blt_rect(dst, bm, src)
      y = dst.y
      ye = dst.y + dst.height
      xe = dst.x + dst.width
      sw = src.width
      sh = src.height
      while y < ye
        x = dst.x
        while x < xe
          blt(x, y, bm, src)
          x += sw
        end
        y += sh
      end
    end

    def repeat_blt(*args)
      x,y,w,h,bm,rect = args
      if RGSS::Rect === x
        return repeat_blt_rect(*args)
      else
        return repeat_blt_rect(RGSS::Rect.new(x, y, w, h), bm, rect)
      end
    end

    def address
      CPtr.new(object_id*2)[4][2][4]
    end

    def getBitmap(rect = self.rect)
      x = RGSS::Bitmap.new(rect.width, rect.height)
      x.blt(0, 0, self, rect)
      x
    end

    def split(opt = {})
      ret = {}
      opt.each{|k, v|
        r = case v
          when Rect then v
          when Array then Rect.new(*v)
        end
        ret[k] = getBitmap(r)
      }
      ret
    end

    def savebmp(filename)
      write_data filename, 
        [0x4d42, (len = width*height*4), 0, 0, 54].pack("SLSSL"),
        CPtr.new(object_id*2)[4][2][2][0, 40],
        address[0, len]
    end

    def savepng(filename)
      write_data filename,
        (signature = "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"),

        [13].pack("N"),
        (header = ["IHDR", width, height, 8, 6, 0, 0, 0].pack("a4NNCCCCC")),
        [Zlib.crc32(header)].pack("N"),

        [width*height*4+height].pack("N"),
        (dat = "IDAT" << Zlib::Deflate.deflate(address[0, (cw = width* 4) * (ch = height)].instance_eval{
           ret = []
           (ch-1).downto(0){|x|
             ret << "" << self[x*cw, cw].unpack("L*").map{|x|
               (x & 0xFF0000) >> 16 | (x & 0xFF) << 16 | (x & 0xFF00FF00)
             }.pack("L*")
           }
           ret.join
        })),
        [Zlib.crc32(dat)].pack("N"),
        "\x00\x00\x00\x00\x49\x45\x4E\x44\xAE\x42\x60\x82"
    end

    def with_tone!(tone)
      address[0, width*height*4] = address[0, width*height*4].unpack("L*").map{|long|
        b, g, r, a = [long].pack("L").unpack("C*")
        grayfull = (r * 38 + g * 75 + b * 15) >> 7
        r = tone.red  + r + (grayfull - r) * tone.gray / 256  
        g = tone.green+ g + (grayfull - g) * tone.gray / 256
        b = tone.blue + b + (grayfull - b) * tone.gray / 256
        [b, g, r, a].pack("C*").unpack("L").first
      }.pack("L*")
      self
    end

    def with_tone(tone)
      clone.with_tone!
    end

  end

  module Sprite
    def image
      b = RGSS::Bitmap.new(src_rect.width, src_rect.height)
      b.blt(0, 0, bitmap, src_rect)
      b
    end

    def image=(bitmap)
      rect = bitmap.rect
      rect.width  = [rect.width, src_rect.width].min
      rect.height = [rect.height, src_rect.height].min
      self.bitmap.blt(rect.x, rect.y, bitmap, bitmap.rect)
    end
  end

  module Plane
    def image
      b = RGSS::Bitmap.new((Graphics.width  + bitmap.width - 1) / bitmap.width * bitmap.width, 
                     (Graphics.height + bitmap.height - 1) / bitmap.height * bitmap.height)
      a = b.rect.dup
      a.x = -self.ox
      a.y = -self.oy
      b.repeat_blt(a, self.bitmap, self.bitmap.rect)
      b
    end
  end

  module Font
    def marshal_dump
      ret = []
      [:name, :size, :bold, :italic, :outline, :shadow, :color, :out_color].each{|k|
        ret << [k, send(k)] if respond_to?(k)
      }
      ret
    end

    def marshal_load(obj)
      obj.each{|x|
        k, v = x
        self.send "#{k}=", v
      }
    end
  end

end

class Object
 include RGSS3Facets::Object
end

class Module
 include RGSS3Facets::Module
end

class Class
 include RGSS3Facets::Class
end

class Proc
 include RGSS3Facets::Proc
end

class Range
 include RGSS3Facets::Range
end

class Rect
 include RGSS3Facets::Rect  
end

class Binding
  include RGSS3Facets::Binding
end

class Exception
  include RGSS3Facets::Exception
end

class IO
  extend RGSS3Facets::IO_extend
end

class RegExp
  include RGSS3Facets::RegExp
end

class Symbol
  include RGSS3Facets::Symbol
end

class String
  include RGSS3Facets::String
end

class Sprite
  include RGSS3Facets::Sprite
end

class Plane
  include RGSS3Facets::Plane
end

class Bitmap
  include RGSS3Facets::Bitmap

  module BitmapMarshalPolicy
    class Raw
      def self._dump(obj)
        [obj.width, obj.height].pack("LL")+ obj.address[0, obj.width*obj.height*4]
      end

      def self._load(arg)
        w, h = arg.unpack("LL")
        bi = RGSS3Facets::RGSS::Bitmap.new(w, h)
        bi.address[0, w*h*4] = arg[8..-1]
        bi
      end
    end

    class RawCompress
      def self._dump(obj)
        [obj.width, obj.height].pack("LL")+ Zlib::Deflate.deflate(obj.address[0, obj.width*obj.height*4])
      end

      def self._load(arg)
        w, h = arg.unpack("LL")
        bi = RGSS3Facets::RGSS::Bitmap.new(w, h)
        bi.address[0, w*h*4] = Zlib::Inflate.inflate(arg[8..-1])
        bi
      end
    end

    class BitmapFile
      def self._dump(obj)
        [0x4d42, (len = obj.width*obj.height*4), 0, 0, 54].pack("SLSSL") <<
        RGSS3Facets::CPtr.new(obj.object_id*2)[4][2][2][0, 40] <<
        obj.address[0, len]
      end

      def self._load(arg)
        w, h = arg[18, 8].unpack("LL")
        obj = RGSS3Facets::RGSS::Bitmap.new(w, h)
        obj.address[0, w*h*4] = arg[54..-1]
        obj
      end
    end
  end

  MarshalPolicy = :Raw

  def _dump(limit)
    self.class::BitmapMarshalPolicy.const_get(self.class::MarshalPolicy)._dump(self)
  end

  def self._load(obj)
    self.class::BitmapMarshalPolicy.const_get(self.class::MarshalPolicy)._load(obj)
  end
end

class Font
  include RGSS3Facets::Font
end

module RGSS3Facets::Enumerable

  def partial_sum(start, *s)
    if block_given?
      inject([start], *s) do |a, b|
        a << yield(a[-1], b)
      end
    else
      v = s[0].to_proc
      inject([start]) do |a, b|
        a << v.call(a[-1], b)
      end
    end
  end
end

Class.each_object{|klass|
  klass.send :include, RGSS3Facets::Enumerable if klass.ancestors.include?(Enumerable)
}

#load_script "Data/utils/api.rb"
#load_script "Data/utils/gc.rb"

Seiran API v1.7 beta 0.04 for RGSS

2014 年 2 月 19 日

一种新的调用API的包装，因为API不包装也可以调用，其实就是自己的脚本综合练习一类的东西吧：

用法:

鼠标指针：

def mouse_pos
  api{
    import 'user32'
    # 点是两个uint， 传入的int[2].*是两个uint的指针
    return GetCursorPos(uint[2].*).out[0].values
    #传出参数的第0个是这个指针，values取得他的内容（两个点）  
  }
end

def mouse_pos

api{

import 'user32'

# 点是两个uint，传入的int[2].*是两个uint的指针

return GetCursorPos(uint[2].*).out[0].values

#传出参数的第0个是这个指针，values取得他的内容（两个点）

}

end

自定义结构体的鼠标指针：

def point(x = int(0), y = int(0))
  tuple(x, y)
end

def mouse_pos
  api{
    import 'user32'
    return GetCursorPos(*point).out[0].values
  }
end

def point(x = int(0), y = int(0))

tuple(x, y)

end

def mouse_pos

api{

import 'user32'

return GetCursorPos(*point).out[0].values

}

end

Win32API rescue require 'win32api' 
#API 1.7

# http://seiran.mist.so
class API
  class CPtr
    RMM = Win32API.new("Kernel32", "RtlMoveMemory", "LLL", "L")
    SLEN = Win32API.new("Kernel32", "lstrlenA", "L", "L")
    WLEN = Win32API.new("Kernel32", "lstrlenW", "L", "L")
    def initialize(start, len = 0)
      @start, @len = start, len
    end
    def [](st, le)
      buf = ""*le
      RMM.call *[buf, @start+st, le].pack("pLL").unpack("L*")
      buf
    end
    def +(a)
      CPtr.new(@start+a, @len)
    end
    def []=(st, le, str)
      RMM.call *[@start+st, str, [le,str.size].min].pack("LpL").unpack("L*")
    end
    def to_s(size = nil)
      a = SLEN.call(to_i) 
      size ||= a
      self[0, [size, a].min]
    end
    def to_ws(size = nil)
      a = WLEN.call(to_i) 
      size ||= a
      self[0, [size, a].min * 2]
    end
    def to_i
      @start
    end
  end

  module ArrayType
    def [](size)
      API::Tuple.new([self] * size)
    end
  end

  module PointerType
    def *(*a)
      API::Pointer.new(self)
    end
    def to_ary(*a)
      [API::Pointer.new(self)]
    end
  end

  class Tuple
    include ArrayType
    include PointerType

    def initialize(args)
      @args = args
    end

    def pack
      @objects   = []
      @mark      = []
      @valuestr  = ""
      pos = 0
      @args.each{|x|
        case x
          when Integer then @valuestr << [x].pack("L"); pos += 4
          when String  then @valuestr << [x].pack("p"); @mark << x; pos += 4
          else @objects << [x, pos]; @valuestr << (u = x.pack); pos += u.size
        end
      }
      @valuestr
    end

    def unpack(ptr)
      out = []
      @objects.each{|x| a, b = x; out << a.unpack(ptr + b); }
      out
    end
  end

  class SingleType
    include ArrayType
    include PointerType
    def initialize(a = 0, packchar = "L", size = 4); @a = a; @p = packchar; @size = size; @buf = [@a].pack(packchar);end
    def pack; @buf; end
    def unpack(ptr); ptr[0, @size].unpack(@p).first; end
  end

  def uint(a = 0)    SingleType.new(a)  end
  def int(a = 0)     SingleType.new(a, "l") end
  alias ulong uint
  alias long  int
  alias uint32 uint
  alias int32 int

  def char(a = 0) SingleType.new(a, "c") end
  def byte(a = 0) SingleType.new(a, "C") end
  alias uchar byte
  alias u8    byte
  alias uint8 byte
  alias int8  char

  def short(a = 0) SingleType.new(a, "s") end
  def ushort(a = 0) SingleType.new(a, "S") end
  alias uint16 ushort
  alias int16  short

  def longlong(a = 0)  SingleType.new(a, "q", 8) end
  def ulonglong(a = 0) SingleType.new(a, "Q", 8) end
  alias uint64 ulonglong
  alias int64  longlong

  def float(v)  SingleType.new(v, "F", 4) end
  def double(v) SingleType.new(v, "D", 8) end
  alias real   float
  alias real32 float
  alias real64 double

  def packed_char(v) SingleType.new(v, "c", 1) end
  def packed_short(v) SingleType.new(v, "s", 2) end

  class PointerToTuple
    def initialize(tuple, ptr)
      @tuple, @ptr = tuple, ptr
    end
    def value
      @tuple.unpack(@ptr)
    end

  end

  class Pointer
    include ArrayType
    include PointerType
    def initialize(obj = API::Tuple.new([])); @obj = obj; @obj = API::Tuple.new([@obj]) unless Tuple === @obj;@str = @obj.pack; @ptr = [@str].pack("p"); end
    def pack; @ptr; end
    def unpack(ptr); PointerToTuple.new(@obj, API::CPtr.new(ptr[0, 4].unpack("L").first)) end
  end

  class BufferAnsiString
    include ArrayType
    include PointerType

    def initialize(size = nil, &b)
      r = if b then b.call else nil end
      @size = size || r.size
      @buf = r || ""*@size
    end
    def pack
      @buf
    end
    def unpack(ptr)
      ptr.to_s(@size)
    end
  end

  class BufferWideString
    include ArrayType
    include PointerType

    def initialize(size = nil, &b)
      r = if b then b.call else nil end
      @size = (size ? size * 2 : nil)|| r.size
      @buf = r || ""*@size
    end
    def pack
      @buf
    end
    def unpack(ptr)
      ptr.to_ws(@size)
    end
  end

  class Buffer
    include ArrayType
    include PointerType

    def initialize(size)
      @size = size
      @buf = ""*@size
    end
    def pack
      @buf
    end
    def unpack(ptr)
      ptr[0, @size]
    end
  end

  def pointer(obj = tuple())
    Pointer.new(obj)
  end

  def buffer(size)
    Buffer.new(size)
  end  

  def string(size = nil, &b)
    BufferAnsiString.new(size, &b)
  end

  def wstring(size = nil, &b)
    BufferWideString.new(size, &b)
  end

  def array(size, typesym)
    tuple(*Array.new(size).map{send typesym})
  end

  attr_accessor :caller

  class ResultType
    def initialize(ret, out)
      @ret, @out = ret, out
    end
    def to_int
      @ret.to_int
    end
    def to_i
      @ret.to_i
    end
    def coerce(v)
      case v
        when Fixnum; [v, to_int]
        when String; [v, to_str]
      end
    end
    def method_missing(sym, *args)
      @ret.send sym, *args
    end
    def to_str
      @ret.to_str
    end
    def to_s
      @ret.to_s
    end
    def value
      @ret
    end
    def out
      @out
    end
    def first
      @out.first
    end
    def last
      @out.last
    end
    def [](a)
      @out[a]
    end
  end

  class Caller
    attr_accessor :imports
    def initialize    
      self.imports = []
      @api = API.new
    end
    def guess(sym, num)
      params = "L"*num
      vsyms = ["_#{sym}", "#{sym}", "_#{sym}@#{num}", "#{sym}@#{num}"]
      self.imports.map{|x|
        vsyms.map{|y|
         begin
            Win32API.new(x, y, params, "L") 
          rescue LoadError # Ruby >= 1.9
            nil
          rescue RuntimeError # RMXP
            nil
         end
        }
      }.flatten.compact
    end

    def call_win32api(sym, *args)
      t = API::Tuple.new(args)
      r = t.pack
      v = guess(sym, r.size / 4)
      ret = v[0].call *r.unpack("L"*args.size)
      out = t.unpack(API::CPtr.new([r].pack("p").unpack("L").first))
      ResultType.new(ret, out)
    end

    def asm_push(a)
      @api.tuple(@api.packed_char(0x68), a) 
    end

    def asm_addesp(a)
      @api.tuple(@api.packed_short(0xc483), a)
    end
    def asm_func_begin
      @api.tuple(@api.packed_short(0x8b55), @api.packed_char(0xec))
    end

    def asm_func_end
       @api.int(0x0010c2c9)
    end

    def asm_call(a)
      @api.tuple(
        @api.packed_char(0xb8), @api.int(a),
        @api.packed_short(0xd0ff) 
      )
    end

    def call_stdcall(addr, *args)
      t = [asm_func_begin]
      t.concat args.reverse.map{|x| asm_push(x)}
      t.concat [asm_call(addr)]
      t.concat [asm_func_end]
      api{
        import 'user32'
        return CallWindowProc pointer(tuple(*t)), 0, 0, 0, 0
      }
    end

    def call_cdecl(addr, *args)
      t = [asm_func_begin]
      t.concat args.reverse.map{|x| asm_push(x)}
      t.concat [asm_call(addr)]
      t.concat [asm_addesp(@api.char(args.size * 4))]
      t.concat [asm_func_end]
      api{
        import 'user32'
        return CallWindowProc pointer(tuple(*t)), 0, 0, 0, 0
      }
    end

  end

  def setup
    self.caller = Caller.new
  end

  def import(name)
    self.caller.imports << name unless self.caller.imports.include?(name)
    self
  end

  def tuple(*args)
    Tuple.new(args) 
  end

  def method_missing(sym, *args)
    self.caller.call_win32api(sym, *args)
  end

  def stdcall(addr, *args)
    self.caller.call_stdcall(addr, *args)
  end

  def ccall(addr, *args)
    self.caller.call_cdecl(addr, *args)
  end

end

def api(&b)
  x = API.new
  x.setup
  x.instance_eval(&b) if b
  x
end

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

Win32API rescue require 'win32api'

#API 1.7

# http://seiran.mist.so

class API

class CPtr

RMM = Win32API.new("Kernel32", "RtlMoveMemory", "LLL", "L")

SLEN = Win32API.new("Kernel32", "lstrlenA", "L", "L")

WLEN = Win32API.new("Kernel32", "lstrlenW", "L", "L")

def initialize(start, len = 0)

@start, @len = start, len

end

def [](st, le)

buf = ""*le

RMM.call *[buf, @start+st, le].pack("pLL").unpack("L*")

buf

end

def +(a)

CPtr.new(@start+a, @len)

end

def []=(st, le, str)

RMM.call *[@start+st, str, [le,str.size].min].pack("LpL").unpack("L*")

end

def to_s(size = nil)

a = SLEN.call(to_i)

size ||= a

self[0, [size, a].min]

end

def to_ws(size = nil)

a = WLEN.call(to_i)

size ||= a

self[0, [size, a].min * 2]

end

def to_i

@start

end

module ArrayType

def [](size)

API::Tuple.new([self] * size)

end

module PointerType

def *(*a)

API::Pointer.new(self)

end

def to_ary(*a)

[API::Pointer.new(self)]

end

class Tuple

include ArrayType

include PointerType

def initialize(args)

@args = args

end

def pack

@objects = []

@mark = []

@valuestr = ""

pos = 0

@args.each{|x|

case x

when Integer then @valuestr << [x].pack("L"); pos += 4

when String then @valuestr << [x].pack("p"); @mark << x; pos += 4

else @objects << [x, pos]; @valuestr << (u = x.pack); pos += u.size

end

}

@valuestr

end

def unpack(ptr)

out = []

@objects.each{|x| a, b = x; out << a.unpack(ptr + b); }

out

end

class SingleType

include ArrayType

include PointerType

def initialize(a = 0, packchar = "L", size = 4); @a = a; @p = packchar; @size = size; @buf = [@a].pack(packchar);end

def pack; @buf; end

def unpack(ptr); ptr[0, @size].unpack(@p).first; end

end

def uint(a = 0) SingleType.new(a) end

def int(a = 0) SingleType.new(a, "l") end

alias ulong uint

alias long int

alias uint32 uint

alias int32 int

def char(a = 0) SingleType.new(a, "c") end

def byte(a = 0) SingleType.new(a, "C") end

alias uchar byte

alias u8 byte

alias uint8 byte

alias int8 char

def short(a = 0) SingleType.new(a, "s") end

def ushort(a = 0) SingleType.new(a, "S") end

alias uint16 ushort

alias int16 short

def longlong(a = 0) SingleType.new(a, "q", 8) end

def ulonglong(a = 0) SingleType.new(a, "Q", 8) end

alias uint64 ulonglong

alias int64 longlong

def float(v) SingleType.new(v, "F", 4) end

def double(v) SingleType.new(v, "D", 8) end

alias real float

alias real32 float

alias real64 double

def packed_char(v) SingleType.new(v, "c", 1) end

def packed_short(v) SingleType.new(v, "s", 2) end

class PointerToTuple

def initialize(tuple, ptr)

@tuple, @ptr = tuple, ptr

end

def value

@tuple.unpack(@ptr)

end

class Pointer

include ArrayType

include PointerType

def initialize(obj = API::Tuple.new([])); @obj = obj; @obj = API::Tuple.new([@obj]) unless Tuple === @obj;@str = @obj.pack; @ptr = [@str].pack("p"); end

def pack; @ptr; end

def unpack(ptr); PointerToTuple.new(@obj, API::CPtr.new(ptr[0, 4].unpack("L").first)) end

end

class BufferAnsiString

include ArrayType

include PointerType

def initialize(size = nil, &b)

r = if b then b.call else nil end

@size = size || r.size

@buf = r || ""*@size

end

def pack

@buf

end

def unpack(ptr)

ptr.to_s(@size)

end

class BufferWideString

include ArrayType

include PointerType

def initialize(size = nil, &b)

r = if b then b.call else nil end

@size = (size ? size * 2 : nil)|| r.size

@buf = r || ""*@size

end

def pack

@buf

end

def unpack(ptr)

ptr.to_ws(@size)

end

class Buffer

include ArrayType

include PointerType

def initialize(size)

@size = size

@buf = ""*@size

end

def pack

@buf

end

def unpack(ptr)

ptr[0, @size]

end

def pointer(obj = tuple())

Pointer.new(obj)

end

def buffer(size)

Buffer.new(size)

end

def string(size = nil, &b)

BufferAnsiString.new(size, &b)

end

def wstring(size = nil, &b)

BufferWideString.new(size, &b)

end

def array(size, typesym)

tuple(*Array.new(size).map{send typesym})

end

attr_accessor :caller

class ResultType

def initialize(ret, out)

@ret, @out = ret, out

end

def to_int

@ret.to_int

end

def to_i

@ret.to_i

end

def coerce(v)

case v

when Fixnum; [v, to_int]

when String; [v, to_str]

end

def method_missing(sym, *args)

@ret.send sym, *args

end

def to_str

@ret.to_str

end

def to_s

@ret.to_s

end

def value

@ret

end

def out

@out

end

def first

@out.first

end

def last

@out.last

end

def [](a)

@out[a]

end

class Caller

attr_accessor :imports

def initialize

self.imports = []

@api = API.new

end

def guess(sym, num)

params = "L"*num

vsyms = ["_#{sym}", "#{sym}", "_#{sym}@#{num}", "#{sym}@#{num}"]

self.imports.map{|x|

vsyms.map{|y|

begin

Win32API.new(x, y, params, "L")

rescue LoadError # Ruby >= 1.9

nil

rescue RuntimeError # RMXP

nil

end

}

}.flatten.compact

end

def call_win32api(sym, *args)

t = API::Tuple.new(args)

r = t.pack

v = guess(sym, r.size / 4)

ret = v[0].call *r.unpack("L"*args.size)

out = t.unpack(API::CPtr.new([r].pack("p").unpack("L").first))

ResultType.new(ret, out)

end

def asm_push(a)

@api.tuple(@api.packed_char(0x68), a)

end

def asm_addesp(a)

@api.tuple(@api.packed_short(0xc483), a)

end

def asm_func_begin

@api.tuple(@api.packed_short(0x8b55), @api.packed_char(0xec))

end

def asm_func_end

@api.int(0x0010c2c9)

end

def asm_call(a)

@api.tuple(

@api.packed_char(0xb8), @api.int(a),

@api.packed_short(0xd0ff)

)

end

def call_stdcall(addr, *args)

t = [asm_func_begin]

t.concat args.reverse.map{|x| asm_push(x)}

t.concat [asm_call(addr)]

t.concat [asm_func_end]

api{

import 'user32'

return CallWindowProc pointer(tuple(*t)), 0, 0, 0, 0

}

end

def call_cdecl(addr, *args)

t = [asm_func_begin]

t.concat args.reverse.map{|x| asm_push(x)}

t.concat [asm_call(addr)]

t.concat [asm_addesp(@api.char(args.size * 4))]

t.concat [asm_func_end]

api{

import 'user32'

return CallWindowProc pointer(tuple(*t)), 0, 0, 0, 0

}

end

def setup

self.caller = Caller.new

end

def import(name)

self.caller.imports << name unless self.caller.imports.include?(name)

self

end

def tuple(*args)

Tuple.new(args)

end

def method_missing(sym, *args)

self.caller.call_win32api(sym, *args)

end

def stdcall(addr, *args)

self.caller.call_stdcall(addr, *args)

end

def ccall(addr, *args)

self.caller.call_cdecl(addr, *args)

end

def api(&b)

x = API.new

x.setup

x.instance_eval(&b) if b

end

BMVC for RGSS 1.00

2014 年 2 月 4 日

1. BMVC是什么？

BMVC是RGSS中实现多个窗口或者精灵，或者他们的混合架构的一个脚本，可以用来简化代码。
相对于单个的窗体Window/精灵Sprite而言，BMVC可以同时有多个显示对象被控制。比如应用物品时，物品描述窗口，物品选择窗口和对象选择窗口是三个窗口，但有关联。可以用BMVC实现。
而相对于场景Scene而言，BMVC比Scene要轻量，也可以嵌入Scene中。
所以也可以放在事件中，比如一个物品选择窗口，没必要创建一个类。

BMVC是RGSS系列上对MVC模式(http://zh.wikipedia.org/wiki/MVC)的一个特化实现，因为RGSS默认脚本本身已经实现一系列与模型有关的东西比如$game_…，这里只需要和他们建立各种关系即可，这种关系模型在本脚本叫做BindingModel，故本脚本命名为BindingModel-View-Controller

2. 如何使用?

有两个重要的方法，一个是K，一个是B，K创建视图和有关的控制器，B创建和模型的绑定。

写在K里面的self.xxx，如果他是一个window或者sprite的话，会自动update和dispose

第一个例子，显示一个有Hello world的窗口，按回车(Input::C)时退出，因为不含任何可变的数据，所以没有用到B。

K{
  a = self.window = Window.new
  a.width = 132
  a.height = 132
  self.bitmap = a.contents = Bitmap.new(100, 100)
  self.bitmap.draw_text(a.contents.rect, "Hello world")
}.run :C => :exit

a = self.window = Window.new

a.width = 132

a.height = 132

self.bitmap = a.contents = Bitmap.new(100, 100)

self.bitmap.draw_text(a.contents.rect, "Hello world")

}.run :C => :exit

下面这个例子的窗口将要显示一个全局变量$a，并且当你按下回车键时，$a会加上1，并且显示也对应变化，注意变化的部分用B{}括起来。相对于上面那个例子，实际上就是把不变的”Hello world”换成了变化的$a.to_s,这里我们用B{$a.to_s}括起来。（同时加上了contents.clear清除内容这样的行为，不然前后写的文字会重叠在一起）

$a = 0
K{
  a = self.mywindow = Window.new
  self.mywindow.width = 132
  self.mywindow.height = 132
  self.bitmap = self.mywindow.contents = Bitmap.new(100, 100)
  B{
    self.bitmap.clear
    self.bitmap.draw_text(0, 0, 100, 100, B{$a.to_s})
  }
}.run :B => :exit, :C => proc{$a += 1}

$a = 0

a = self.mywindow = Window.new

self.mywindow.width = 132

self.mywindow.height = 132

self.bitmap = self.mywindow.contents = Bitmap.new(100, 100)

self.bitmap.clear

self.bitmap.draw_text(0, 0, 100, 100, B{$a.to_s})

}

}.run :B => :exit, :C => proc{$a += 1}

因为按下回车键时，$a加上了1，所以$a.to_s会变化，B{$a.to_s}会把这个变化反馈给外面那个B{}，

因此重新进行了绘制.

实现：

module Kittiko

end

module Kittiko::BindingModel
  attr_accessor :block

  def self.stack
    @stack ||= []
  end

  def changed?
    @changed
  end

  def check_block
    @check_block ||= []
  end

  def add_block(&b)
    check_block << Kittiko::Binding.new(&b)
  end

  def B(&b)
    if Kittiko::BindingModel.stack[-1] && !Kittiko::BindingModel.stack[-1].sealed
      Kittiko::BindingModel.stack[-1].add_block &b
      b.call
    else
      b.call
    end
  end

  def calc
    @cache = block.call
  end

  def update_binding
    if check_block.empty?
      @cache ||= calc
    else
      if @model_cache != (a = check_block.map{|x| x.calc})
        @model_cache = a
        @cache ||= calc
      else
        @cache
      end
    end
  end

end

class Kittiko::Binding
  include Kittiko::BindingModel
  attr_accessor :sealed
  def initialize(&b)
    self.sealed = false
    Kittiko::BindingModel.stack.push self
    self.block = b
    b.call if b
    Kittiko::BindingModel.stack.pop
    self.sealed = true
  end
end

class Kittiko::Container
  include Kittiko::BindingModel
  attr_accessor :sealed
  def initialize(str, &b)
    @__symbols__ = []
    self.sealed = false
    Kittiko::BindingModel.stack.push self
    instance_eval str    
    instance_eval &b if b
    self.block = proc{}
    Kittiko::BindingModel.stack.pop
    self.sealed = true
  end

  def method_missing(sym, *args)
    @__symbols__.push(('@'+sym.to_s.chomp("=")).to_sym)
    (class << self; self; end).send :attr_accessor, sym.to_s.chomp("=")
    send sym, *args
  end

  def each
    @__symbols__.each do |x| yield instance_variable_get(x) end
  end

  def reverse_each
    @__symbols__.reverse.each do |x| yield instance_variable_get(x) end
  end

  def update
    each{|x| x.update if x.respond_to?(:update)}
    update_binding
  end

  def dispose
    reverse_each{|x| x.dispose  if x.respond_to?(:dispose)}
  end

  def run_proc(v)
    case v
      when Symbol
        send v
      when Kittiko::Container
        v.run
      when Proc
        instance_eval &v
      else
        instance_eval v
    end
  end

  def run_loop(opt = {})
    @exit = false
    until @exit
      run_once(opt)
    end
  end

  def run_once(opt = {})
    Graphics.update
    Input.update
    update
    opt.each{|k, v|
      run_proc(v) if case k
        when Symbol
          Input.trigger?(Input.const_get(k))
        when Proc
          instance_eval &k
        end
    }
  end

  def run(opt = {})
    run_loop opt
    dispose
  end

  def exit
    @exit = true
  end

  def self.uniform_define_setter(*symbols)
    symbols.each do |sym| 
        class_eval "
          def #{sym}(value)
             each{|x| x.#{sym} = value }
          end
        "
    end
  end
  uniform_define_setter :ox, :oy, :x, :y, :zoom_x, :zoom_y, :angle, 
                        :opacity, :content_opacity, :back_opacity,
                        :z, :width, :height, :active, :mirror, :bush_depth,
                        :blend_type, :color, :tone, :visible

end

def K(a = "", &b)
  return Kittiko::Container if a == "" && !b
  Kittiko::Container.new(a, &b)
end

class Kittiko::EventBase
  def self.keypress?(k)
    proc{Input.press?(Input.const_get(k))}
  end

  def self.keytrigger?(k)
    proc{Input.trigger?(Input.const_get(k))}
  end

  def self.keyrepeat?(k)
    proc{Input.repeat?(Input.const_get(k))}
  end

end

class Kittiko::Scope
  def self.[](name)
      BindObject.new(name)
  end

  class BindObject
    def initialize(name)
      @name = name
    end

    [:+, :-, :*, :/, :<, :>, :==, :>=, :<=].each{|x|
      class_eval %{
        def #{x}(rhs)
          u = @name
          lambda{ instance_variable_get(u) #{x} rhs}
        end
      }
    }
  end
end

E = Kittiko::EventBase
S = Kittiko::Scope

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

module Kittiko

end

module Kittiko::BindingModel

attr_accessor :block

def self.stack

@stack ||= []

end

def changed?

@changed

end

def check_block

@check_block ||= []

end

def add_block(&b)

check_block << Kittiko::Binding.new(&b)

end

def B(&b)

if Kittiko::BindingModel.stack[-1] && !Kittiko::BindingModel.stack[-1].sealed

Kittiko::BindingModel.stack[-1].add_block &b

b.call

else

b.call

end

def calc

@cache = block.call

end

def update_binding

if check_block.empty?

@cache ||= calc

else

if @model_cache != (a = check_block.map{|x| x.calc})

@model_cache = a

@cache ||= calc

else

@cache

end

class Kittiko::Binding

include Kittiko::BindingModel

attr_accessor :sealed

def initialize(&b)

self.sealed = false

Kittiko::BindingModel.stack.push self

self.block = b

b.call if b

Kittiko::BindingModel.stack.pop

self.sealed = true

end

class Kittiko::Container

include Kittiko::BindingModel

attr_accessor :sealed

def initialize(str, &b)

@__symbols__ = []

self.sealed = false

Kittiko::BindingModel.stack.push self

instance_eval str

instance_eval &b if b

self.block = proc{}

Kittiko::BindingModel.stack.pop

self.sealed = true

end

def method_missing(sym, *args)

@__symbols__.push(('@'+sym.to_s.chomp("=")).to_sym)

(class << self; self; end).send :attr_accessor, sym.to_s.chomp("=")

send sym, *args

end

def each

@__symbols__.each do |x| yield instance_variable_get(x) end

end

def reverse_each

@__symbols__.reverse.each do |x| yield instance_variable_get(x) end

end

def update

each{|x| x.update if x.respond_to?(:update)}

update_binding

end

def dispose

reverse_each{|x| x.dispose if x.respond_to?(:dispose)}

end

def run_proc(v)

case v

when Symbol

send v

when Kittiko::Container

v.run

when Proc

instance_eval &v

else

instance_eval v

end

def run_loop(opt = {})

@exit = false

until @exit

run_once(opt)

end

def run_once(opt = {})

Graphics.update

Input.update

update

opt.each{|k, v|

run_proc(v) if case k

when Symbol

Input.trigger?(Input.const_get(k))

when Proc

instance_eval &k

end

}

end

def run(opt = {})

run_loop opt

dispose

end

def exit

@exit = true

end

def self.uniform_define_setter(*symbols)

symbols.each do |sym|

class_eval "

def #{sym}(value)

each{|x| x.#{sym} = value }

end

uniform_define_setter :ox, :oy, :x, :y, :zoom_x, :zoom_y, :angle,

:opacity, :content_opacity, :back_opacity,

:z, :width, :height, :active, :mirror, :bush_depth,

:blend_type, :color, :tone, :visible

end

def K(a = "", &b)

return Kittiko::Container if a == "" && !b

Kittiko::Container.new(a, &b)

end

class Kittiko::EventBase

def self.keypress?(k)

proc{Input.press?(Input.const_get(k))}

end

def self.keytrigger?(k)

proc{Input.trigger?(Input.const_get(k))}

end

def self.keyrepeat?(k)

proc{Input.repeat?(Input.const_get(k))}

end

class Kittiko::Scope

def self.[](name)

BindObject.new(name)

end

class BindObject

def initialize(name)

@name = name

end

[:+, :-, :*, :/, :<, :>, :==, :>=, :<=].each{|x|

class_eval %{

def #{x}(rhs)

u = @name

lambda{ instance_variable_get(u) #{x} rhs}

end

}

end

E = Kittiko::EventBase

S = Kittiko::Scope