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

手抽去重发明两个boost的轮子

2014 年 1 月 18 日

调的心情郁闷了
http://codepad.org/2lep9EjC
http://codepad.org/ChE9zOgB

用Windows批处理做网站

2014 年 1 月 7 日

其实在上古时代也没有php啦asp这些神器。。有perl或者甚至C语言来做服务器网页就已经很不错了。。。这里的本质是通过执行这些程序，输出的文本，当做HTTP内容返回。如果你看见有些老网站的地址中有/cgi-bin/，那基本上就是了。

这里兰兰用的是WAMP，windows下的一个一键快捷安装的个人服务器套件。如果你没有修改他的设置，比如装在C:\WAMP，那么这个目录应该是C:\WAMP\cgi-bin，新建一个hello.cmd，输入下面的代码：然后访问http://localhost/cgi-bin/hello.cmd?name=Hello&var=3就可以看到结果。不过这个代码的最后一行set %b:~1,-1%和中间某行call :parse_uri “%QUERY_STRING%”实际上可以被注入代码，因此用于生产环境是很不安全的，这里仅仅是用来卖萌(demostration)。

@echo off
echo Content-Type:text/html; charset=GBK
echo.
echo ^<H1^>Hello world^</H1^>
call :parse_uri "%QUERY_STRING%"
if not "%name%"=="" (
 @echo Your name is ^<font color=#F00^>%name%^</font^>^<BR/^>
 @echo Your var is ^<font color=#F00^>%var%^</font^>^<BR/^>
)

echo.
goto :eof

:parse_uri
set a=%*
set b=%a:&=&set %
set %b:~1,-1%

@echo off

echo Content-Type:text/html; charset=GBK

echo.

echo ^<H1^>Hello world^</H1^>

call :parse_uri "%QUERY_STRING%"

if not "%name%"=="" (

@echo Your name is ^<font color=#F00^>%name%^</font^>^<BR/^>

@echo Your var is ^<font color=#F00^>%var%^</font^>^<BR/^>

)

echo.

goto :eof

:parse_uri

set a=%*

set b=%a:&=&set %

set %b:~1,-1%

[RGSS]RGStorage 1.00

2013 年 12 月 16 日

介绍

RGStorage实现了一个通用的存储类，统一接口，可以从以下实际或虚拟文件系统来读写文件资料

文件系统
ar文件
RGSS加密系统（只读）。

并可以通过可选的扩展来读写

7z文件
zip文件
http://开头的资源

同时在以上的基础上重定义了require方法，也可以混入Object，使它能像普通的Ruby的require一样工作，但不局限于require具体文件，比如：

require “http://codepad.org/abcdefgh/raw.rb”
require “1.zip!/test.rb”
require “RGSSAD://a.rb”

基本用法：

把一个类似于文件路径的字符串叫做资源标识符(resource identifier, rsrc_id)。

因为可以通过RGStorage::Active来重新设定关联，以下的用法的举例与默认关联有关。

1.RGStorage.get rsrc_id

取得资源的内容

RGStorage.get “C:\\windows\\system32\\notepad.exe”#相当于直接读取notepad.exe
RGStorage.get “extended.ar!/Sc330.exe” #从ar文件取得Sc330.exe，作为字符串返回
RGStorage.get “http://example.com/sample.zip”#从http读取数据，需要扩展文件extended.ar
RGStorage.get “<T>prefix”#取一个临时文件名，前缀是prefix，也就是返回”临时文件夹\\prefix0001″这样的形式
RGStorage.get “a.zip!/a.png” # 从zip读数据，需要扩展(extended.ar)

2. RGStorage.set rsrc_id, content

设置资源的内容

RGStorage.set “1.txt”, “Hello world” #相当于往1.txt里面写Hello world字符串
RGStorage.set “mytest.ar!/1.txt”, “Hello world” #往ar文件里面某个项目写内容
RGStorage.set “a.zip!/a.png”, “pngdata” #往zip里面某个文件写内容，需要扩展(extended.ar)

3. RGStorage.copyTo rsrc_id1, rsrc_id2

复制资源内容，相当于RGStorage.set(rsrc_id2, RGStorage.get(rsrc_id1))

RGStorage.copyTo “1.txt”, “a.zip!/2.txt” #相当于添加/更新1.txt到a.zip，文件名改为2.txt
RGStorage.copyTo “http://test.com/sample.exe”, “b.exe” #相当于下载文件

基本设置：

默认设置是：

 RGStorage::Active = RGController.new RGRouter.new [
     [/\.ar!/, ArSystem],
     [/\.ar/, FileSystem, MarshalFormatter, ZlibFormatter],
     [/<T>.*/, TemporaryFile],
     [/\.*/, FileSystem]
    ]

RGStorage::Active = RGController.new RGRouter.new [

[/\.ar!/, ArSystem],

[/\.ar/, FileSystem, MarshalFormatter, ZlibFormatter],

[/<T>.*/, TemporaryFile],

[/\.*/, FileSystem]

]

其中每一个设置的格式为，

[ 匹配条件，文件系统，转换器1，转换器2，转换器3，…]

匹配条件可以是正则表达式，范围，或者一个接受一个参数返回真假值的lambda/proc

文件系统是RGFileSystem类的实例，或者实现了get/set方法的对象，如果可以get/set一个rsrc_id，那么get/set的调用将返回一个lambda{|rsrc|}(get)或者lambda{|rsrc, content|}(set)，否则应该返回nil，这是用来测试一个文件是否可读/可写

转换器也是实现了get/set方法的对象，或者RGFormatter类的实例，但get/set直接返回转换结果，比如MarshalFormatter的get方法是对输入(记为input)返回Marshal.load(input)的结果，而set刚好相反。

RGSSType alpha 0.1

2013 年 11 月 27 日

一个用于直接在RGSS3的位图上写文字的类，

不经过bitmap.draw_text，而是直接写像素，

就算RGSS3启动时没有安装字体，安装字体之后使用RGSSType.new仍然有用

这个版本只实现了一个简单的写字体方法，而且并没有作为Bitmap的方法被定义

用法：

RGSSType#font

返回RGSSType使用的Font对象，可以设置他的字型字号颜色等, 文字轮廓阴影暂时不支持。

RGSSType#writetext(bitmap, string, x, y, color[, height])

在bitmap上，从(x, y)开始书写文字string, height

=begin
  RGSSType Alpha 0.1
  Author: 晴兰 Seiran
  Website: http://seiran.mist.so
  License:
    Copyright (c) 2013, Seiran
    All rights reserved.
    Redistribution and use in source and binary forms, with or without 
    modification, are permitted provided that the following conditions are met:
    1. Redistributions of source code must retain the above copyright notice, 
    this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice, 
    this list of conditions and the following disclaimer in the documentation 
    and/or other materials provided with the distribution.
    3. Neither the name of the seiran.mist.so nor the names of its contributors 
    may be used to endorse or promote products derived from this software 
    without specific prior written permission.
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 
    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
    POSSIBILITY OF SUCH DAMAGE.
=end

#encoding:UTF-8
module SAFX
  module_function

  def to_param(a)
    case a when Integer then "L" when String then "p" end
  end

  def to_ptr(a)
    case a  when Integer then a when String then [a].pack('p').unpack("L").first end
  end

  def api(dll,func)
    lambda{|*args|
       Win32API.new(dll,func,args.map{|x|to_param(x)}, 'i').call(*args)
    }
  end

  def to_wc(str, cp = 65001)
    (buf = ""*str.length)[0, 2*api('Kernel32', 'MultiByteToWideChar').call(cp, 
    0, to_ptr(str), -1, buf, buf.length)]
  end

  def to_mb(str, cp = 65001)
    (buf = ""* str.length)[0, api('Kernel32', 'WideCharToMultiByte').call(cp, 
    0, to_ptr(str), -1, buf, buf.length, 0, 0)]
  end

end

class RGSSType
  module API
    FUNC = {}
    HANDLES  = [DL::dlopen('gdi32'), DL::dlopen("KERNEL32"), 
    DL::dlopen("USER32")]
    def self.method_missing(sym, *args)
      FUNC[sym] ||= DL::CFunc.new(
        HANDLES.map{|x| x[sym.to_s] rescue nil}.compact[0] ,
        DL::TYPE_VOIDP, '', :stdcall
      )      
      FUNC[sym].call(args.map{|x| DL::CPtr[x]})
    end
  end

  attr_accessor :font

  def initialize(font = ::Font.new ,w = 300, h = 300)
    @font = font
    @dc = API.CreateCompatibleDC(0)
    @ptr = DL.malloc(w * h * 4)
    @bitmap = API.CreateBitmap(w, h, 1, 32, @ptr)
    @w, @h = w, h
    DL.free(@ptr)
    resetfont
  end

  def resetfont
    API.DeleteObject(@hfont) if @hfont != nil
    API.SelectOBject(@dc, @hold) if @hold != nil
    @hold = nil
    @hfont = nil
  end

  def bits
    buf = [].pack("x#{@w * @h * 4}")
    API.GetBitmapBits(@bitmap, buf.size, buf)
    buf
  end

  def boolvalue a
    a ? 1 : 0
  end

  def dispose
    resetfont
    API.DeleteObject(@bitmap)
    API.ReleaseDC(@dc)
  end

  def createfont
    resetfont
    args = [@font.size, 0, 0, 0, 
            @font.bold ? 700 : 400, 
            boolvalue(@font.italic), 
            0,0,
            1, #default_charset
            0,0,4,0,
            SAFX.to_wc(@font.name+"")]
    #                        here^
    @hfont = API.CreateFontW(*args)
    @hold = API.SelectObject(@dc, @hfont)
  end

  def getchar8b(a)
    API.GetGlyphIndicesW(@dc, SAFX.to_wc(a+""), 1, (index=[].pack("x4")), 0)
    #                                    here^
    index = index.unpack("L").first
    glyph = [].pack("x24")
    mat   = [0,1,0,0,0,0,0,1].pack("S*")
    len   = API.GetGlyphOutline(@dc, index, 0x85, glyph, 0, 0, mat)
    buf   = [].pack "x#{len}"
    len = API.GetGlyphOutline(@dc, index, 0x85, glyph, len, buf, mat)
    bx, by, ox, oy, cx, cy = glyph.unpack("llllss")
    [buf, bx, by, ox, oy, cx, cy, len]
  end

  def char_height(ch)
    u =  getchar8b(ch)
    height = u[5]
  end

  def writechar8b(bitmap, ch, cx, cy, color, height = nil)
    u =  getchar8b(ch)
    r,g,b,a=color.red, color.green, color.blue, color.alpha
    return [0, 0] if u[0].size == 0
    colors = 256.times.map{|x|
      Color.new(r * x  * 4 / 256, g * x  * 4 / 256, b * x  * 4 / 256, a)
    }
    i = 0
    height ||= u[0].size / ((u[1] + 3) / 4 * 4)
    v = u[0].unpack("C*")
    u[2].times{|y|
      u[1].times{|x|
         bitmap.set_pixel(x + cx + u[3], cy + height - u[4] + y, colors[v[i]*4])
         i += 1
      }
      i = (i + 3) >> 2 << 2
    }
    [u[5], u[6]]
  end

  def writetext(bitmap, text, cx, cy, color)
    createfont
    height = text.split(//).map{|x| char_height(x)}.max
    text.split(//).each{|ch|
      w,h = writechar8b(bitmap, ch, cx, cy, color, height)
      cx += w
    }
  end
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

=begin

RGSSType Alpha 0.1

Author: 晴兰 Seiran

Website: http://seiran.mist.so

License:

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,

this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,

this list of conditions and the following disclaimer in the documentation

and/or other materials provided with the distribution.

3. Neither the name of the seiran.mist.so nor the names of its contributors

may be used to endorse or promote products derived from this software

without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

=end

#encoding:UTF-8

module SAFX

module_function

def to_param(a)

case a when Integer then "L" when String then "p" end

end

def to_ptr(a)

case a when Integer then a when String then [a].pack('p').unpack("L").first end

end

def api(dll,func)

lambda{|*args|

Win32API.new(dll,func,args.map{|x|to_param(x)}, 'i').call(*args)

}

end

def to_wc(str, cp = 65001)

(buf = ""*str.length)[0, 2*api('Kernel32', 'MultiByteToWideChar').call(cp,

0, to_ptr(str), -1, buf, buf.length)]

end

def to_mb(str, cp = 65001)

(buf = ""* str.length)[0, api('Kernel32', 'WideCharToMultiByte').call(cp,

0, to_ptr(str), -1, buf, buf.length, 0, 0)]

end

class RGSSType

module API

FUNC = {}

HANDLES = [DL::dlopen('gdi32'), DL::dlopen("KERNEL32"),

DL::dlopen("USER32")]

def self.method_missing(sym, *args)

FUNC[sym] ||= DL::CFunc.new(

HANDLES.map{|x| x[sym.to_s] rescue nil}.compact[0] ,

DL::TYPE_VOIDP, '', :stdcall

)

FUNC[sym].call(args.map{|x| DL::CPtr[x]})

end

attr_accessor :font

def initialize(font = ::Font.new ,w = 300, h = 300)

@font = font

@dc = API.CreateCompatibleDC(0)

@ptr = DL.malloc(w * h * 4)

@bitmap = API.CreateBitmap(w, h, 1, 32, @ptr)

@w, @h = w, h

DL.free(@ptr)

resetfont

end

def resetfont

API.DeleteObject(@hfont) if @hfont != nil

API.SelectOBject(@dc, @hold) if @hold != nil

@hold = nil

@hfont = nil

end

def bits

buf = [].pack("x#{@w * @h * 4}")

API.GetBitmapBits(@bitmap, buf.size, buf)

buf

end

def boolvalue a

a ? 1 : 0

end

def dispose

resetfont

API.DeleteObject(@bitmap)

API.ReleaseDC(@dc)

end

def createfont

resetfont

args = [@font.size, 0, 0, 0,

@font.bold ? 700 : 400,

boolvalue(@font.italic),

0,0,

1, #default_charset

0,0,4,0,

SAFX.to_wc(@font.name+"")]

# here^

@hfont = API.CreateFontW(*args)

@hold = API.SelectObject(@dc, @hfont)

end

def getchar8b(a)

API.GetGlyphIndicesW(@dc, SAFX.to_wc(a+""), 1, (index=[].pack("x4")), 0)

# here^

index = index.unpack("L").first

glyph = [].pack("x24")

mat = [0,1,0,0,0,0,0,1].pack("S*")

len = API.GetGlyphOutline(@dc, index, 0x85, glyph, 0, 0, mat)

buf = [].pack "x#{len}"

len = API.GetGlyphOutline(@dc, index, 0x85, glyph, len, buf, mat)

bx, by, ox, oy, cx, cy = glyph.unpack("llllss")

[buf, bx, by, ox, oy, cx, cy, len]

end

def char_height(ch)

u = getchar8b(ch)

height = u[5]

end

def writechar8b(bitmap, ch, cx, cy, color, height = nil)

u = getchar8b(ch)

r,g,b,a=color.red, color.green, color.blue, color.alpha

return [0, 0] if u[0].size == 0

colors = 256.times.map{|x|

Color.new(r * x * 4 / 256, g * x * 4 / 256, b * x * 4 / 256, a)

}

i = 0

height ||= u[0].size / ((u[1] + 3) / 4 * 4)

v = u[0].unpack("C*")

u[2].times{|y|

u[1].times{|x|

bitmap.set_pixel(x + cx + u[3], cy + height - u[4] + y, colors[v[i]*4])

i += 1

}

i = (i + 3) >> 2 << 2

}

[u[5], u[6]]

end

def writetext(bitmap, text, cx, cy, color)

createfont

height = text.split(//).map{|x| char_height(x)}.max

text.split(//).each{|ch|

w,h = writechar8b(bitmap, ch, cx, cy, color, height)

cx += w

}

end

Seiran API v1.7 beta 0.04 for RGSS

BMVC for RGSS 1.00

手抽去重发明两个boost的轮子

用Windows批处理做网站

[RGSS]RGStorage 1.00

介绍

基本用法：

基本设置：

RGSSType alpha 0.1

SAFX进展报告(updating)

【原创】论另一种把Ruby翻译成其他语言的思路（不需要AST相关）

1. 目的。

编译原理学习手记(1)– 代码生成(updating)

晴兰的反向Ruby教程-2 RMVA小程序