双人五子棋小游戏

有丘直方

本来想附件售价3经验的……后来想想还是弄三个，第一个是纯文本的，免费；第二个是Scripts.rvdata2，售价1经验；第三个是完整的、带RGSS300.dll的发行包，售价2经验。

第一个（内容较多）

请新建一个工程，游戏名定为《五子棋》，然后删除MAP001，再打开脚本编辑器，删除所有预置脚本，再把以下脚本放进脚本编辑器。
这些脚本中包含了Sion的鼠标系统的核心脚本，但没有包含其他内容，所以不算侵权之类的吧。为尊重原作者，不需要的内容并没有直接删去，而是Ctrl+Q注释掉了；自己增添的内容用“#↓-----↓”和“#↑-----↑”标示出来了

1. # 白菜组基础脚本 WhiteCabbageBase）v1.02 (2013/11/16)
   
2. #
   
3. module APIs
   
4. def self.new(ts); Win32API.new(*ts.split('|')) end
   
5. #-------------------------------------------------
   
6. ClipCursor          = new 'user32|ClipCursor|p|l'
   
7. FindWindowEx        = new 'user32|FindWindowEx|llpp|i'
   
8. GetAsyncKeyState    = new 'user32|GetAsyncKeyState|i|i'
   
9. GetCursorPos        = new 'user32|GetCursorPos|p|i'
   
10. GetKeyState         = new 'user32|GetKeyState|i|i'
    
11. GetPrvPflString     = new 'kernel32|GetPrivateProfileString|pppplp|l'
    
12. GetSysMtr           = new 'user32|GetSystemMetrics|i|i'
    
13. JoyGetPosEx         = new 'winmm|joyGetPosEx|lp|l'
    
14. KeybdEvent          = new 'user32|keybd_event|iill|v'
    
15. MultiByteToWideChar = new 'kernel32|MultiByteToWideChar|ilpipi|i'
    
16. WideCharToMultiByte = new 'kernel32|WideCharToMultiByte|ilpipipp|i'
    
17. RtlMoveMemory_pi    = new 'kernel32|RtlMoveMemory|pii|i'
    
18. RtlMoveMemory_ip    = new 'kernel32|RtlMoveMemory|ipi|i'
    
19. ScreenToClient      = new 'user32|ScreenToClient|ip|i'
    
20. SetCursorPos        = new 'user32|SetCursorPos|ii|l'
    
21. SetFocus            = new 'user32|SetFocus|l|l'
    
22. SetKeyBoardState    = new 'user32|SetKeyboardState|i|i'
    
23. SetWindowPos        = new 'user32|SetWindowPos|liiiiip|i'
    
24. ShellExecuteA       = new 'shell32|ShellExecuteA|pppppi|i'
    
25. ShowCursor          = new 'user32|ShowCursor|i|l'
    
26. #-----------------------------------------------
    
27. HWnd = FindWindowEx.call(0, 0, 'RGSS Player', 0)
    
28. end
    
29. # §
    
30. # Base Class~~~~~~~~~~~~~~~~~~~~~~~~~~
    
31. class NilClass
    
32.   def +(v) return v end
    
33.   def -(v) return -v end
    
34.   def *(v) return 0 end
    
35.   def /(v) return 0 end
    
36. end
    
37. class Numeric
    
38.   def fpart; self - self.to_i end #获取小数部分
    
39.   def rfpart; 1 - fpart end # 1 - 小数部分
    
40.   def max(v); self > v ? self : v end # 取最大值
    
41.   def min(v); self < v ? self : v end # 取最小值
    
42.   def tide(r); self * (rand-0.5)*2 * r end #进行权值波动 ± v * (-r ~ r)
    
43.   def digits(ary=10) # 获取对应进制下的数字位数 2/8/10/16 进制
    
44.     dig = 0; num = self.abs.to_i; if ary == 10; until num == 0; dig += 1
    
45.     num /= ary; end; else ary = case ary; when 2;1; when 8;3; when 16;4 end
    
46.     until num == 0; dig += 1; num = num >> ary end; end; return dig
    
47.   end
    
48. end
    
49. class Array
    
50.   def iswap(a, b)
    
51.     t_ = self[a]
    
52.     self[a] = self[b]
    
53.     self[b] = t_
    
54.   end
    
55. end
    
56. class Hash
    
57.   def iswap(a, b)
    
58.     t_ = self[a]
    
59.     self[a] = self[b]
    
60.     self[b] = t_
    
61.   end
    
62.   def key_sort(rev = false)
    
63.     a = []; h = {}
    
64.     self.each {|k, v| a.push([v, k])}
    
65.     a.sort!
    
66.     rev ? a.reverse_each {|vk| h[vk[1]] = vk[0]} :
    
67.       a.each {|vk| h[vk[1]] = vk[0]}
    
68.     return h
    
69.   end
    
70. end
    
71. # ~~~~~~~~~~~~~~~~~~~~~
    
72. # =====================
    
73. class Font
    
74.   def marshal_dump;        end
    
75.   def marshal_load(*args); end
    
76. end
    
77. # =====================
    
78. class Bitmap
    
79. include APIs
    
80.   #Bitmap marshal. by 柳之一（rpg.blue）
    
81.   # --------------------------------------
    
82.   def _dump(limit)
    
83.     data = bit_4 * width * height
    
84.     RtlMoveMemory_pi.call(data, address, data.length)
    
85.     [width, height, Zlib::Deflate.deflate(data)].pack("LLa*")
    
86.   end
    
87.   def self._load(str)
    
88.     w, h, zdata = str.unpack("LLa*"); buf = new(w, h)
    
89.     RtlMoveMemory_ip.call(buf.address, Zlib::Inflate.inflate(zdata), w*h*4)
    
90.     return buf
    
91.   end
    
92.   def address
    
93.     buf = bit_4
    
94.     ad = object_id * 2 + 16
    
95.     RtlMoveMemory_pi.call(buf, ad, 4)
    
96.     ad = buf.unpack("L")[0] + 8
    
97.     RtlMoveMemory_pi.call(buf, ad, 4)
    
98.     ad = buf.unpack("L")[0] + 16
    
99.     RtlMoveMemory_pi.call(buf, ad, 4)
    
100.     buf.unpack("L")[0]
     
101.   end
     
102.   def bit_4
     
103.     'ccav'
     
104.   end
     
105.   # --------------------------------------
     
106.   # 绘制直线
     
107.   def blt_wu_line(x1, y1, x2, y2, r,g,b,a=255) # 抗锯齿
     
108.     dx = x2 - x1
     
109.     dy = y2 - y1
     
110.     if dx.abs < dy.abs
     
111.       t_ = x1; x1 = y1; y1 = t_
     
112.       t_ = x2; x2 = y2; y2 = t_
     
113.       t_ = dx; dx = dy; dy = t_
     
114.     end
     
115.     if x2 < x1
     
116.       t_ = x1; x1 = x2; x2 = t_
     
117.       t_ = y1; y1 = y2; y2 = t_
     
118.     end
     
119.     set_pixel(x1, y1, Color.new(r,g,b,a))
     
120.     set_pixel(x2, y2, Color.new(r,g,b,a))
     
121.     gradient = dy.fdiv(dx)
     
122.     intery = y1 + gradient
     
123.     for x in (x1 + 1)..(x2 - 1)
     
124.       y1 = intery.to_i
     
125.       y2 = intery.ceil
     
126.       set_pixel(x, y1, Color.new(r,g,b, intery.rfpart * a))
     
127.       set_pixel(x, y2, Color.new(r,g,b, intery.fpart * a)) if y1 != y2
     
128.       intery = intery + gradient
     
129.     end
     
130.   end
     
131.   def blt_line(x0, y0, x1, y1, r,g,b,a=255) # 不抗锯
     
132.     c = Color.new(r,g,b,a)
     
133.     steep = (y1 - y0).abs > (x1 - x0).abs
     
134.     if steep
     
135.       t_ = x0; x0 = y0; y0 = t_
     
136.       t_ = x1; x1 = y1; y1 = t_
     
137.     end
     
138.     if x0 > x1
     
139.       t_ = x0; x0 = x1; x1 = t_
     
140.       t_ = y0; y0 = y1; y1 = t_
     
141.     end
     
142.     deltax = x1 - x0
     
143.     deltay = (y1 - y0).abs
     
144.     error  = deltax / 2
     
145.     y = y0
     
146.     ystep = y0 < y1 ? 1 : -1
     
147.     for x in x0..x1
     
148.       steep ? set_pixel(y,x,c) : set_pixel(x,y,c)
     
149.       error = error - deltay
     
150.       if error < 0
     
151.         y = y + ystep
     
152.         error = error + deltax
     
153.       end
     
154.     end
     
155.   end
     
156.   # 描边 -----------------------------
     
157.   def blt_border(w = 1, d = 0, color = Color.new(255, 255, 255))
     
158.     fill_rect(d, d, width - d*2, w, color)
     
159.     fill_rect(d, height - d - w, width - d*2, w, color)
     
160.     fill_rect(d, d, w, height - d*2 - w, color)
     
161.     fill_rect(width - d - w, d*2, w, height - d*2 - w, color)
     
162.     return self
     
163.   end
     
164.   def clear_4angle_dot
     
165.     clear_rect(0, 0, 1, 1)
     
166.     clear_rect(width - 1, 0, 1, 1)
     
167.     clear_rect(0, height - 1, 1, 1)
     
168.     clear_rect(width - 1, height - 1, 1, 1)
     
169.     return self
     
170.   end
     
171.   # 纵向中心渐变
     
172.   def vert_center_gradual(c2)
     
173.     c1 = Color.new
     
174.     self.gradient_fill_rect(0, 0, width, height/2, c1, c2, true)
     
175.     self.gradient_fill_rect(0, height/2, width, height/2, c2, c1, true)
     
176.     return self
     
177.   end
     
178. end
     
179. # =======================
     
180. class Sprite
     
181.   def center_screen_xy
     
182.     self.x = Graphics.width / 2
     
183.     self.y = Graphics.height / 2
     
184.   end
     
185.   def center_origin
     
186.     self.ox = (width + 1) / 2
     
187.     self.oy = (height + 1) / 2
     
188.   end
     
189.   def set_origin_tone
     
190.     self.tone = $game_map.screen.tone.inverse
     
191.   end
     
192.   def zoom(v) # 缩放精灵
     
193.     self.zoom_x = v
     
194.     self.zoom_y = v
     
195.   end
     
196. end
     
197. # =====================
     
198. class Table
     
199.   def fill(value) # 填充Table
     
200.     if ysize == 1
     
201.       xsize.times {|i| self[i] = value}
     
202.     elsif zsize == 1
     
203.       ysize.times {|j| xsize.times {|i| self[i,j] = value}}
     
204.     else
     
205.       zsize.times {|k| ysize.times {|j| xsize.times {|i| self[i,j,k] = value}}}
     
206.     end
     
207.     return self
     
208.   end
     
209.   def amend(value)
     
210.     if ysize == 1
     
211.       xsize.times {|i| self[i] += value}
     
212.     elsif zsize == 1
     
213.       ysize.times {|j| xsize.times {|i|self[i,j] += value}}
     
214.     else
     
215.       zsize.times {|k| ysize.times {|j| xsize.times {|i| self[i,j,k] += value}}}
     
216.     end
     
217.     return self
     
218.   end
     
219.   #
     
220.   def self.new_by(array) #利用数组中的16进制信息创建一个Table
     
221.     xsize = array[0].digits(16) - 1
     
222.     ysize = array.size
     
223.     table = Table.new(xsize, ysize)
     
224.     ysize.times {|y|
     
225.       bit = array[y]
     
226.       xsize.times {|x|
     
227.         table[xsize - x - 1, y] = (bit >> x*4) & 0xf
     
228.       }
     
229.     }
     
230.     return table
     
231.   end
     
232. end
     
233. # =====================
     
234. class Tone
     
235.   def inverse
     
236.     Tone.new(-red, -green, -blue)
     
237.   end
     
238. end
     
239. # =====================
     
240. #~ class << SceneManager
     
241. #~   def goto(scene_class, *args)
     
242. #~     [url=home.php?mod=space&uid=420706]@Scene[/url] = scene_class.new(*args)
     
243. #~   end
     
244. #~   def call(scene_class, *args)
     
245. #~     @stack.push(@scene)
     
246. #~     @scene = scene_class.new(*args)
     
247. #~   end
     
248. #~ end
     
249. #
     
250. class << Input
     
251. include APIs
     
252.   def key_press?(key)
     
253.     0 != GetAsyncKeyState.call(key)
     
254.   end
     
255.   def key_on?(key)
     
256.     1 == GetKeyState.call(key) & 1
     
257.   end
     
258.   def key_repeat?(key) # 该方法最好每帧只调用一次
     
259.     GetAsyncKeyState.call(key) & 1 == 1
     
260.   end
     
261.   #
     
262.   def press_shift?
     
263.     key_press?(0xA0) || key_press?(0xA1)
     
264.   end
     
265.   def press_ctrl?
     
266.     key_press?(0xA2) || key_press?(0xA3)
     
267.   end
     
268.   def press_alt?
     
269.     key_press?(0xA4) || key_press?(0xA5)
     
270.   end
     
271.   def refresh_all_keys
     
272.     255.times {|i| key_press?(i)}
     
273.   end
     
274. end
     
275. #~ # ============================
     
276. #~ class Window_Base
     
277. #~   def draw_escape_text_al(text, x = 0, y = 0) #绘制文字自动换行
     
278. #~     reset_font_settings
     
279. #~     pos = {:x => x, :y => y, :new_x => x, :height => calc_line_height(text)}
     
280. #~     text = convert_escape_characters(text)
     
281. #~     process_characters_al(text.slice!(0, 1), text, pos) until text.empty?
     
282. #~   end
     
283. #~   def process_characters_al(c, text, pos)
     
284. #~     case c
     
285. #~     when "\r", "\n"; return
     
286. #~     when "\f"; process_new_page(text, pos)
     
287. #~     when "\e"; process_escape_character(obtain_escape_code(text), text, pos)
     
288. #~     else       process_character_al(c, pos)
     
289. #~     end
     
290. #~   end
     
291. #~   def process_character_al(c, pos) #处理自动换行
     
292. #~     tw = text_size(c).width
     
293. #~     process_new_line(c, pos) if pos[:x] + tw > contents.width - pos[:new_x]
     
294. #~     draw_text(pos[:x], pos[:y], tw * 2, pos[:height], c)
     
295. #~     pos[:x] += tw
     
296. #~   end
     
297. #~ end

复制代码

1. # 基础鼠标模组（Sion_MouseBase）v1.01 （2013/11/5）
   
2. # 需求! 白菜组脚本基 (WhiteCabbageBase) v1.0+
   
3. #
   
4. # 鼠标指针图片 MouseCursor.png 放入 Graphics\System 文件夹
   
5. # 按下 Alt + L 将鼠标锁定在屏幕内； Alt + O（字母欧） 解除锁定
   
6. 
   
7. module Mouse end
   
8. class << Mouse
   
9. DCF = 15 # 判断双击间隔帧数
   
10. include APIs
    
11. attr_reader :left_state, :right_state
    
12.   def activate(vp = nil)
    
13.     @dk_count = 0
    
14.     hide_system_cursor
    
15.     create_cursor(vp)
    
16.   end
    
17.   def update
    
18.     update_cursor
    
19.     update_click
    
20.     update_mouse_lock
    
21.     update_right_click
    
22.   end
    
23.   def deactivate
    
24.     show_system_cursor
    
25.     dispose_cursor
    
26.   end
    
27. 
    
28. 
    
29.   def create_cursor(vp)
    
30.     dispose_cursor if @sprite
    
31.     @sprite = Sprite.new(vp)
    
32.     @sprite.z = 9999
    
33.     if File.exist?('Graphics/System/MouseCursor.png')
    
34.       @sprite.bitmap = Cache.system('MouseCursor')
    
35.     else
    
36.       @sprite.bitmap = Bitmap.new(30, 30)
    
37. #~       @sprite.bitmap.blt(0, 0, Cache.system('Iconset'),
    
38. #~         Rect.new(5 * 24, 24 * 24, 24, 24))
    
39. # ↓---------------------------------------------------------------↓
    
40.       for i in 1..6
    
41.         @sprite.bitmap.fill_rect(i,i,i,i, Color.new(0,0,0))
    
42.       end
    
43. # ↑---------------------------------------------------------------↑
    
44.     end
    
45.     update_cursor
    
46.   end
    
47.   def dispose_cursor
    
48.     return if @sprite.disposed?
    
49.     @sprite.bitmap.dispose
    
50.     @sprite.dispose
    
51.   end
    
52. 
    
53.   def update_cursor
    
54.     buf = '00000000'
    
55.     GetCursorPos.call(buf)
    
56.     ScreenToClient.call(HWnd, buf)
    
57.     x, y = buf.unpack('ll')
    
58.     @sprite.x = x
    
59.     @sprite.y = y
    
60.   end
    
61.   def update_click
    
62.     @left_state  = GetAsyncKeyState.call(0x01) == 0 ? 0 : @left_state  + 1
    
63.     @right_state = GetAsyncKeyState.call(0x02) == 0 ? 0 : @right_state + 1
    
64.   end
    
65. 
    
66.   #
    
67.   def x
    
68.     @sprite.x
    
69.   end
    
70.   def y
    
71.     @sprite.y
    
72.   end
    
73. # ↓---------------------------------------------------------------↓
    
74.   def area?(x,y=nil,w=nil,h=nil)
    
75.     if y == nil
    
76.       self.x.between?(x.x,x.x+x.width) and self.y.between?(x.y,x.y+x.height)
    
77.     else
    
78.       self.x.between?(x,x+w) and self.y.between?(y,y+h)
    
79.     end
    
80.   end
    
81. # ↑---------------------------------------------------------------↑
    
82.   def press?(sym)
    
83.     state(sym) > 0
    
84.   end
    
85.   def trigger?(sym)
    
86.     state(sym) == 1
    
87.   end
    
88.   def repeat?(sym)
    
89.     s = state(sym)
    
90.     s == 1 || s > 19 && s % 5 == 0
    
91.   end
    
92.   def state(sym)
    
93.     case sym
    
94.     when :L; @left_state
    
95.     when :R; @right_state
    
96.     end
    
97.   end
    
98.   #
    
99.   def update_right_click
    
100.     if @left_state == 1
     
101.       @ck_count = 0
     
102.       @clicked = true
     
103.     else
     
104.       @ck_count += 1
     
105.     end
     
106.     if @dk_count > 0 && @left_state == 1
     
107.       @dk_count = 0; @clicked = false
     
108.       return @double_click = true
     
109.     elsif @clicked
     
110.       if @dk_count < DCF
     
111.         @dk_count += 1
     
112.       else
     
113.         @dk_count = 0
     
114.         @clicked = false
     
115.       end
     
116.     end
     
117.     @double_click = false
     
118.   end
     
119.   def double_click?
     
120.     @double_click
     
121.   end
     
122.   def click_count
     
123.     @ck_count
     
124.   end
     
125.   #
     
126.   def update_mouse_lock # press Alt + L 锁定 Alt + O 解除锁定
     
127.     if GetAsyncKeyState.call(0xA4) != 0 || GetAsyncKeyState.call(0xA5) != 0
     
128.       return lock   if GetAsyncKeyState.call(0x4C) != 0
     
129.       return unlock if GetAsyncKeyState.call(0x4F) != 0
     
130.     end
     
131.   end
     
132.   def lock
     
133.     x, y = get_window_pos
     
134.     ClipCursor.call([-x, -y, Graphics.width-x, Graphics.height-y].pack('llll'))
     
135.   end
     
136.   def unlock
     
137.     ClipCursor.call(0)
     
138.   end
     
139.   def show_system_cursor
     
140.     begin state = ShowCursor.call(1) end while state < 0
     
141.   end
     
142.   def hide_system_cursor
     
143.     begin state = ShowCursor.call(0) end while state >= 0
     
144.   end
     
145.   def set_pos(m_x, m_y)
     
146.     x, y = get_window_pos
     
147.     SetCursorPos.call(m_x - x, m_y - y)
     
148.   end
     
149.   #
     
150.   #
     
151.   def get_window_pos
     
152.     buf = [0, 0].pack('ll')#= '00000000'
     
153.     ScreenToClient.call(HWnd, buf)
     
154.     return buf.unpack('ll')
     
155.   end
     
156. end

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Integer
   
4. #------------------------------------------------------------------------------
   
5. #   整数的抽象类。
   
6. #==============================================================================
   
7. 
   
8. class Integer
   
9.   #--------------------------------------------------------------------------
   
10.   # ● 判断self是否为一个偶数
    
11.   #--------------------------------------------------------------------------
    
12.   def even?
    
13.     v = self / 2.0
    
14.     case v - v.truncate
    
15.     when 0.0;       return true
    
16.     when 0.5, -0.5; return false
    
17.     end
    
18.   end
    
19. end
    

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Bitmap
   
4. #------------------------------------------------------------------------------
   
5. #   位图类。
   
6. #==============================================================================
   
7. 
   
8. class Bitmap
   
9.   #--------------------------------------------------------------------------
   
10.   # ● 将位图的圆形填充指定颜色
    
11.   #     ox    ：圆心的x坐标
    
12.   #     oy    ：圆心的y坐标
    
13.   #     radius：圆形的半径
    
14.   #     color ：填充的颜色
    
15.   #--------------------------------------------------------------------------
    
16.   def fill_circle(ox, oy, radius, color)
    
17.     i_max = radius * Math.sqrt(2) / 2
    
18.     square_max = radius * radius + radius / 2
    
19.     x = radius
    
20.     fill_rect(ox - radius, oy, 2 * radius, 1, color)
    
21.     for i in 1..i_max
    
22.       if i * i + x * x > square_max
    
23.         if x > i_max
    
24.           fill_rect(ox - i + 1, oy + x, 2 * (i - 1), 1, color)
    
25.           fill_rect(ox - i + 1, oy - x, 2 * (i - 1), 1, color)
    
26.         end
    
27.         x -= 1
    
28.       end
    
29.       fill_rect(ox - x, oy + i, 2 * x, 1, color)
    
30.       fill_rect(ox - x, oy - i, 2 * x, 1, color)
    
31.     end
    
32.   end
    
33.   #--------------------------------------------------------------------------
    
34.   # ● 将位图填充指定颜色
    
35.   #     color ：填充的颜色
    
36.   #--------------------------------------------------------------------------
    
37.   def fill(color)
    
38.     fill_rect(0, 0, width, height, color)
    
39.   end
    
40. end
    

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Con
   
4. #------------------------------------------------------------------------------
   
5. #   所有的常量和一些方法在这里被设置。
   
6. #==============================================================================
   
7. 
   
8. module Con
   
9.   #--------------------------------------------------------------------------
   
10.   # ● 常量
    
11.   #--------------------------------------------------------------------------
    
12.   # 画面
    
13.   Size          = 480 # 棋盘大小
    
14.   GraphicsWidth = 640 # 画面宽度
    
15.   Checker       = 15  # 棋盘大小（格子）
    
16.   Bulge         = 3   # 棋子的凸度和连珠粗细
    
17.   Tab           = 20  # 缩进值
    
18.   # 颜色
    
19.   White  = Color.new(255, 255, 255) # 白色
    
20.   Black  = Color.new(0, 0, 0)       # 黑色
    
21.   Gray   = Color.new(127, 127, 127) # 灰色
    
22.   Yellow = Color.new(204, 153, 0)   # 土黄色
    
23.   Red    = Color.new(255, 0, 0)     # 红色
    
24.   Blue   = Color.new(0, 0, 102)     # 深蓝色
    
25.   # 时间
    
26.   Game = 15 * Graphics.frame_rate ** 2 # 局时（帧）
    
27.   Step = Graphics.frame_rate ** 2      # 步时（帧）
    
28.   # 文字
    
29.   Title    = "五子棋"                   # 标题
    
30.   Author   = Title + " - 有丘直方 制作" # 作者
    
31.   Nomsg    = "新局开始"                 # 没有消息的情况
    
32.   Success  = "成功"                     # 成功的消息
    
33.   Failure  = "失败"                     # 失败的消息
    
34.   Alphabet = ["a", "b", "c", "d", "e",  # 小写字母表
    
35.               "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",
    
36.               "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
    
37.   #--------------------------------------------------------------------------
    
38.   # ● 搭建环境
    
39.   #--------------------------------------------------------------------------
    
40.   def self.environment
    
41.     Graphics.freeze
    
42.     Graphics.resize_screen(GraphicsWidth, Size)
    
43.     Mouse.activate
    
44.     Font.default_outline = false
    
45.     Font.default_size = Tab
    
46.     Font.default_color = Black
    
47.     Font.default_name = "幼圆"
    
48.   end
    
49.   #--------------------------------------------------------------------------
    
50.   # ● 运行
    
51.   #--------------------------------------------------------------------------
    
52.   def self.run
    
53.     environment
    
54.     scene = Playing.new
    
55.     rgss_main { scene.main }
    
56.   end
    
57. end
    

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Checkerboard
   
4. #------------------------------------------------------------------------------
   
5. #   棋盘的精灵。
   
6. #==============================================================================
   
7. 
   
8. class Checkerboard < Sprite
   
9.   #--------------------------------------------------------------------------
   
10.   # ● 定义实例变量
    
11.   #--------------------------------------------------------------------------
    
12.   attr_reader(:size)
    
13.   #--------------------------------------------------------------------------
    
14.   # ● 初始化对象
    
15.   #--------------------------------------------------------------------------
    
16.   def initialize
    
17.     super()
    
18.     self.bitmap = Bitmap.new(Con::GraphicsWidth, Con::Size)
    
19.     @check = Con::Size / (Con::Checker + 1)
    
20.     draw_background # 绘制底色
    
21.     draw_board      # 绘制棋盘
    
22.     draw_text       # 绘制文字
    
23.     draw_pos        # 绘制坐标
    
24.     @bitmap = bitmap
    
25.   end
    
26.   #--------------------------------------------------------------------------
    
27.   # ● 绘制底色
    
28.   #--------------------------------------------------------------------------
    
29.   def draw_background
    
30.     bitmap.fill(Con::Gray)
    
31.     size = Con::Size - @check * 2
    
32.     rect = Rect.new(@check, @check, size, size)
    
33.     bitmap.fill_rect(rect, Con::Yellow)
    
34.   end
    
35.   #--------------------------------------------------------------------------
    
36.   # ● 绘制棋盘
    
37.   #--------------------------------------------------------------------------
    
38.   def draw_board
    
39.     for i in 1..Con::Checker # 绘制横线
    
40.       x = @check
    
41.       y = @check * i
    
42.       width = Con::Size - @check * 2
    
43.       bitmap.fill_rect(x, y, width, 1, Con::Black)
    
44.     end
    
45.     for i in 1..Con::Checker # 绘制竖线
    
46.       x = @check * i
    
47.       y = @check
    
48.       height = Con::Size - @check * 2
    
49.       bitmap.fill_rect(x, y, 1, height, Con::Black)
    
50.     end
    
51.     for i in 1..3            # 绘制“星”
    
52.       rect = Rect.new(Con::Size / 4 * i - 2, Con::Size / 4 * (4 - i) - 2, 4, 4)
    
53.       bitmap.fill_rect(rect, Con::Black)
    
54.       rect = Rect.new(Con::Size / 4 * i - 2, Con::Size / 4 * i - 2, 4, 4)
    
55.       bitmap.fill_rect(rect, Con::Black)
    
56.     end
    
57.   end
    
58.   #--------------------------------------------------------------------------
    
59.   # ● 绘制文字
    
60.   #--------------------------------------------------------------------------
    
61.   def draw_text
    
62.     v = Con::Tab
    
63.     x = Con::Size - v
    
64.     width = Con::GraphicsWidth - Con::Size
    
65.     bitmap.draw_text(x,     10,  width, v, "——指令——", 1)
    
66.     bitmap.draw_text(x,     30,  width, v, "进程")
    
67.     bitmap.draw_text(x + v, 50,  width, v, "悔棋(Q)")
    
68.     bitmap.draw_text(x + v, 70,  width, v, "新局(W)")
    
69.     bitmap.draw_text(x,     90,  width, v, "文件管理")
    
70.     bitmap.draw_text(x + v, 110, width, v, "保存棋局(F5)")
    
71.     bitmap.draw_text(x + v, 130, width, v, "复盘(F6)")
    
72.     bitmap.draw_text(x,     150, width, v, "落子步数")
    
73.     bitmap.draw_text(x + v, 170, width, v, "全部显示(A)")
    
74.     bitmap.draw_text(x + v, 190, width, v, "显示一手(S)")
    
75.     bitmap.draw_text(x + v, 210, width, v, "不显示(D)")
    
76.     bitmap.draw_text(x,     230, width, v, "坐标")
    
77.     bitmap.draw_text(x + v, 250, width, v, "全部显示(Z)")
    
78.     bitmap.draw_text(x + v, 270, width, v, "不显示(X)")
    
79.     bitmap.draw_text(x,     310, width, v, "——信息——", 1)
    
80.     bitmap.draw_text(x,     330, width, v, "消息")
    
81.     bitmap.draw_text(x,     370, width, v, "计时器")
    
82.     bitmap.font.name = "黑体"
    
83.     bitmap.draw_text(0, 460, Con::Size, v, Con::Author, 1)
    
84.     bitmap.font.name = Font.default_name
    
85.   end
    
86.   #--------------------------------------------------------------------------
    
87.   # ● 绘制坐标
    
88.   #--------------------------------------------------------------------------
    
89.   def draw_pos
    
90.     bitmap.font.color = Con::Black
    
91.     bitmap.font.name = "Times New Roman"
    
92.     size = Con::Tab
    
93.     bitmap.font.italic = true
    
94.     bitmap.font.bold = true
    
95.     for i in 1..Con::Checker # 绘制字母
    
96.       x = @check * i - Con::Tab / 2
    
97.       bitmap.draw_text(x, 0, size, size, Con::Alphabet[i - 1], 1)
    
98.     end
    
99.     bitmap.font.italic = Font.default_italic
    
100.     bitmap.font.bold = Font.default_bold
     
101.     for i in 1..Con::Checker # 绘制数字
     
102.       y = @check * i - Con::Tab / 2
     
103.       bitmap.draw_text(0, y, size, size, i, 1)
     
104.     end
     
105.     bitmap.font.color = Font.default_color
     
106.     bitmap.font.name = Font.default_name
     
107.   end
     
108.   #--------------------------------------------------------------------------
     
109.   # ● 清除坐标
     
110.   #--------------------------------------------------------------------------
     
111.   def clear_pos
     
112.     rect = Rect.new(0, 0, Con::Size, Con::Size / Con::Checker - 2)
     
113.     bitmap.clear_rect(rect)
     
114.     bitmap.fill_rect(rect, Con::Gray)
     
115.     rect = Rect.new(0, 0, Con::Size / Con::Checker - 2, Con::Size)
     
116.     bitmap.clear_rect(rect)
     
117.     bitmap.fill_rect(rect, Con::Gray)
     
118.   end
     
119.   #--------------------------------------------------------------------------
     
120.   # ● 绘制消息
     
121.   #     msg：需要绘制的信息
     
122.   #--------------------------------------------------------------------------
     
123.   def draw_msg(msg)
     
124.     v = Con::Tab
     
125.     x = Con::Size - v
     
126.     width = Con::GraphicsWidth - Con::Size
     
127.     height = Con::Tab
     
128.     bitmap.font.name = "楷体_GB2312"
     
129.     bitmap.clear_rect(x + v, 350, width, height)
     
130.     bitmap.fill_rect(x + v, 350, width, height, Con::Gray)
     
131.     bitmap.draw_text(x + v, 350, width, height, msg)
     
132.     bitmap.font.name = Font.default_name
     
133.   end
     
134.   #--------------------------------------------------------------------------
     
135.   # ● 绘制计时器
     
136.   #     game：局时（数组）
     
137.   #     step：步时（数组）
     
138.   #--------------------------------------------------------------------------
     
139.   def draw_time(game, step)
     
140.     v = Con::Tab
     
141.     x = Con::Size - v
     
142.     width = Con::GraphicsWidth - Con::Size
     
143.     bitmap.clear_rect(rect = Rect.new(x + v, 390, width, v * 4))
     
144.     bitmap.fill_rect(rect, Con::Gray)
     
145.     rect = Rect.new(x + v, 390, width, v)
     
146.     str = "黑方：" + "局时" + time_str(game[0], Con::Game)
     
147.     bitmap.draw_text(rect, str)
     
148.     rect = Rect.new(x + v * 4, 410, width, v)
     
149.     str = "步时" + time_str(step[0], Con::Step)
     
150.     bitmap.draw_text(rect, str)
     
151.     rect = Rect.new(x + v, 430, width, v)
     
152.     str = "白方：" + "局时" + time_str(game[1], Con::Game)
     
153.     bitmap.draw_text(rect, str)
     
154.     rect = Rect.new(x + v * 4, 450, width, v)
     
155.     str = "步时" + time_str(step[1], Con::Step)
     
156.     bitmap.draw_text(rect, str)
     
157.   end
     
158.   #--------------------------------------------------------------------------
     
159.   # ● 获取时间字符串
     
160.   #     time：时间（帧）
     
161.   #     top ：上限（帧）
     
162.   #--------------------------------------------------------------------------
     
163.   def time_str(time, top)
     
164.     rest = top - time
     
165.     rate = Graphics.frame_rate
     
166.     str = ""
     
167.     str += "0" if (v = (minute = (second = rest / rate) / rate)) < 10
     
168.     str += v.to_s
     
169.     str += ":"
     
170.     str += "0" if (v = second - minute * rate) < 10
     
171.     str += v.to_s
     
172.     return str
     
173.   end
     
174.   #--------------------------------------------------------------------------
     
175.   # ● 释放
     
176.   #--------------------------------------------------------------------------
     
177.   def dispose
     
178.     bitmap.dispose
     
179.     super
     
180.   end
     
181. end
     

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Pieces
   
4. #------------------------------------------------------------------------------
   
5. #   棋子的精灵。
   
6. #==============================================================================
   
7. 
   
8. class Pieces < Sprite
   
9.   #--------------------------------------------------------------------------
   
10.   # ● 初始化对象
    
11.   #--------------------------------------------------------------------------
    
12.   def initialize
    
13.     super()
    
14.     self.bitmap = Bitmap.new(Con::Size, Con::Size)
    
15.     self.z = 1
    
16.   end
    
17.   #--------------------------------------------------------------------------
    
18.   # ● 绘制棋子
    
19.   #     x：     棋子的位置x坐标
    
20.   #     y：     棋子的位置y坐标
    
21.   #     id：    棋子的ID
    
22.   #     number：是否绘制落子步数，0:全部显示;1:显示一手;2:不显示
    
23.   #     pieces：当前棋子的总数
    
24.   #--------------------------------------------------------------------------
    
25.   def draw_piece(x, y, id, number, pieces)
    
26.     size = 20
    
27.     v = Con::Size / (Con::Checker + 1)
    
28.     a = v * (x + 1)
    
29.     b = v * (y + 1)
    
30.     u = id
    
31.     rect = Rect.new(a - v / 2, b - v / 2, v, v)
    
32.     bitmap.clear_rect(rect)
    
33.     return if u == 0
    
34.     if u.even?
    
35.       color1 = Con::White
    
36.       color2 = Con::Black
    
37.     else
    
38.       color1 = Con::Black
    
39.       color2 = Con::White
    
40.     end
    
41.     # 绘制棋子外形
    
42.     bitmap.fill_circle(a, b, size / 2 + Con::Bulge, color1)
    
43.     bitmap.fill_circle(a, b, Con::Bulge, Con::Red) if u == pieces # 新标
    
44.     # 绘制落子步数
    
45.     unless u == 0 or number == 2
    
46.       rect = Rect.new(a - size / 2, b - size / 2, Con::Tab, Con::Tab)
    
47.       bitmap.font.color = color2
    
48.       case number
    
49.       when 0; bitmap.draw_text(rect, u, 1)
    
50.       when 1; bitmap.draw_text(rect, u, 1) if u == pieces
    
51.       end
    
52.     end
    
53.   end
    
54.   #--------------------------------------------------------------------------
    
55.   # ● 绘制线段
    
56.   #     x     ：线段起始点的x坐标（格子）
    
57.   #     y     ：线段起始点的y坐标（格子）
    
58.   #     direct：线段方向，0:横;1:纵;2:左斜;3:右斜
    
59.   #     color ：线段的颜色
    
60.   #--------------------------------------------------------------------------
    
61.   def draw_line(x, y, direct, color)
    
62.     v = Con::Size / (Con::Checker + 1)
    
63.     thickness = Con::Bulge
    
64.     x0 = (x + 1.5) * v - thickness / 2
    
65.     y0 = (x + 1.5) * v - thickness / 2
    
66.     x1 = (x + 1)   * v - thickness / 2
    
67.     y1 = (y + 1)   * v - thickness / 2
    
68.     x2 = (x + 0.5) * v - thickness / 2
    
69.     y2 = (y + 0.5) * v - thickness / 2
    
70.     for i in 0..(v * 5)
    
71.       case direct
    
72.       when 0; bitmap.fill_rect(x2 + i, y1,         thickness, thickness, color)
    
73.       when 1; bitmap.fill_rect(x1,     y2 * v + i, thickness, thickness, color)
    
74.       when 2; bitmap.fill_rect(x0 - i, y2 + i,     thickness, thickness, color)
    
75.       when 3; bitmap.fill_rect(x2 + i, y2 + i,     thickness, thickness, color)
    
76.       end
    
77.     end
    
78.   end
    
79.   #--------------------------------------------------------------------------
    
80.   # ● 释放
    
81.   #--------------------------------------------------------------------------
    
82.   def dispose
    
83.     bitmap.dispose
    
84.     super
    
85.   end
    
86. end
    

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Playing
   
4. #------------------------------------------------------------------------------
   
5. #   下棋的场景的类。
   
6. #==============================================================================
   
7. 
   
8. class Playing
   
9.   #--------------------------------------------------------------------------
   
10.   # ● 主逻辑
    
11.   #--------------------------------------------------------------------------
    
12.   def main
    
13.     start           # 开始
    
14.     post_start      # 开始后
    
15.     loop { update } # 更新
    
16.   end
    
17.   #--------------------------------------------------------------------------
    
18.   # ● 开始
    
19.   #--------------------------------------------------------------------------
    
20.   def start
    
21.     @board = Checkerboard.new # 棋盘
    
22.     init_board                # 初始化棋盘
    
23.     @pieces = Pieces.new      # 棋子
    
24.     @number = 0               # 显示数字
    
25.     @pos = 0                  # 显示坐标
    
26.     @sign = false             # 棋子更新标志
    
27.     @msg = Con::Nomsg         # 消息
    
28.   end
    
29.   #--------------------------------------------------------------------------
    
30.   # ● 开始后
    
31.   #--------------------------------------------------------------------------
    
32.   def post_start
    
33.     Graphics.transition
    
34.   end
    
35.   #--------------------------------------------------------------------------
    
36.   # ● 更新
    
37.   #--------------------------------------------------------------------------
    
38.   def update
    
39.     update_basic
    
40.     update_all_sprites
    
41.     last_msg = @msg.clone
    
42.     judge_mouse                     # 判断鼠标
    
43.     judge_key                       # 判断键盘
    
44.     update_pieces if @sign          # 更新棋子
    
45.     unless @lock
    
46.       update_time if @game          # 更新计时器
    
47.       draw_time                     # 绘制计时器
    
48.     end
    
49.     if @msg != last_msg or @msg == Con::Nomsg
    
50.       draw_msg                      # 绘制信息
    
51.     end
    
52.   end
    
53.   #--------------------------------------------------------------------------
    
54.   # ● 基础更新
    
55.   #--------------------------------------------------------------------------
    
56.   def update_basic
    
57.     Graphics.update
    
58.     Mouse.update
    
59.     Input.update
    
60.   end
    
61.   #--------------------------------------------------------------------------
    
62.   # ● 棋盘初始化
    
63.   #--------------------------------------------------------------------------
    
64.   def init_board
    
65.     @msg = "新局开始" + Con::Success
    
66.     @table = Table.new(Con::Checker, Con::Checker)
    
67.     @board.bitmap.font.color = Font.default_color
    
68.     for i in 0...Con::Checker
    
69.       for j in 0...Con::Checker
    
70.         @table[i, j] = 0
    
71.       end
    
72.     end
    
73.     @game_time = [0, 0]       # 局时
    
74.     @step_time = [0, 0]       # 步时
    
75.     @pieces_number = 0
    
76.     @lock = false
    
77.     @game = false
    
78.   end
    
79.   #--------------------------------------------------------------------------
    
80.   # ● 落子
    
81.   #--------------------------------------------------------------------------
    
82.   def go
    
83.     v = Con::Size / (Con::Checker + 1)
    
84.     x = (Mouse.x - v / 2) / v
    
85.     y = (Mouse.y - v / 2) / v
    
86.     if @lock or @table[x, y] != 0
    
87.       @msg = "落子" + Con::Failure
    
88.     else
    
89.       @sign = true
    
90.       @pieces_number += 1
    
91.       index = nil
    
92.       if (@table[x, y] = @pieces_number).even?
    
93.         @msg = "白方落子" + Con::Success
    
94.         index = 1
    
95.       else
    
96.         @msg = "黑方落子" + Con::Success
    
97.         index = 0
    
98.       end
    
99.       @step_time[index] = 0 # 步时归零
    
100.     end
     
101.   end
     
102.   #--------------------------------------------------------------------------
     
103.   # ● 悔棋
     
104.   #--------------------------------------------------------------------------
     
105.   def regret
     
106.     if @pieces_number - 1 != -1
     
107.       @sign = true
     
108.       sign = false
     
109.       for i in 0...Con::Checker
     
110.         for j in 0...Con::Checker
     
111.           if @table[i, j] == @pieces_number
     
112.             sign = true
     
113.             @table[i, j] = 0
     
114.             break
     
115.           end
     
116.         end
     
117.         break if sign
     
118.       end
     
119.       @pieces_number -= 1
     
120.       if @pieces_number.even?
     
121.         @msg = "黑方悔棋" + Con::Success
     
122.       else
     
123.         @msg = "白方悔棋" + Con::Success
     
124.       end
     
125.       @lock = false
     
126.     else
     
127.       @msg = "悔棋" + Con::Failure
     
128.     end
     
129.   end
     
130.   #--------------------------------------------------------------------------
     
131.   # ● 新局
     
132.   #--------------------------------------------------------------------------
     
133.   def new_game
     
134.     @sign = true
     
135.     init_board
     
136.   end
     
137.   #--------------------------------------------------------------------------
     
138.   # ● 保存棋局
     
139.   #--------------------------------------------------------------------------
     
140.   def save
     
141.     File.open("Save.rvdata2", "wb") do |file|
     
142.       Marshal.dump(@table, file)
     
143.     end
     
144.     @msg = "棋局保存" + Con::Success
     
145.   end
     
146.   #--------------------------------------------------------------------------
     
147.   # ● 复盘
     
148.   #--------------------------------------------------------------------------
     
149.   def load
     
150.     @sign = true
     
151.     @msg = "复盘"
     
152.     begin
     
153.       File.open("Save.rvdata2", "rb") do |file|
     
154.         @table = Marshal.load(file)
     
155.         v = 0
     
156.         for i in 0...Con::Checker
     
157.           for j in 0...Con::Checker
     
158.             v = @table[i, j] if v < @table[i, j]
     
159.           end
     
160.         end
     
161.         @pieces_number = v
     
162.       end
     
163.       @msg += Con::Success
     
164.     rescue
     
165.       @msg += Con::Failure
     
166.     end
     
167.   end
     
168.   #--------------------------------------------------------------------------
     
169.   # ● 落子步数
     
170.   #     number: 显示状态，0:全部显示;1:显示一手;2:不显示
     
171.   #--------------------------------------------------------------------------
     
172.   def number(number)
     
173.     @sign = true
     
174.     @number = number
     
175.   end
     
176.   #--------------------------------------------------------------------------
     
177.   # ● 坐标
     
178.   #     pos: 显示状态，0:全部显示;1:不显示
     
179.   #--------------------------------------------------------------------------
     
180.   def pos(pos)
     
181.     @pos = pos
     
182.     draw_pos
     
183.   end
     
184.   #--------------------------------------------------------------------------
     
185.   # ● 判断鼠标
     
186.   #--------------------------------------------------------------------------
     
187.   def judge_mouse
     
188.     if Mouse.trigger?(:L)
     
189.       x = Con::Size
     
190.       width = Con::GraphicsWidth - Con::Size
     
191.       height = Con::Tab
     
192.       if    Mouse.area?(0, 0,   x,     x);      go
     
193.       elsif Mouse.area?(x, 50,  width, height); regret
     
194.       elsif Mouse.area?(x, 70,  width, height); new_game
     
195.       elsif Mouse.area?(x, 110, width, height); save
     
196.       elsif Mouse.area?(x, 130, width, height); load
     
197.       elsif Mouse.area?(x, 170, width, height); number(0)
     
198.       elsif Mouse.area?(x, 190, width, height); number(1)
     
199.       elsif Mouse.area?(x, 210, width, height); number(2)
     
200.       elsif Mouse.area?(x, 250, width, height); pos(0)
     
201.       elsif Mouse.area?(x, 270, width, height); pos(1)
     
202.       end
     
203.     elsif Mouse.trigger?(:R)
     
204.       regret
     
205.     end
     
206.   end
     
207.   #--------------------------------------------------------------------------
     
208.   # ● 判断键盘
     
209.   #--------------------------------------------------------------------------
     
210.   def judge_key
     
211.     if    Input.trigger?(:L);  regret
     
212.     elsif Input.trigger?(:R);  new_game
     
213.     elsif Input.trigger?(:F5); save
     
214.     elsif Input.trigger?(:F6); load
     
215.     elsif Input.trigger?(:X);  number(0)
     
216.     elsif Input.trigger?(:Y);  number(1)
     
217.     elsif Input.trigger?(:Z);  number(2)
     
218.     elsif Input.trigger?(:C);  pos(0)
     
219.     elsif Input.trigger?(:B);  pos(1)
     
220.     end
     
221.   end
     
222.   #--------------------------------------------------------------------------
     
223.   # ● 更新棋子
     
224.   #--------------------------------------------------------------------------
     
225.   def update_pieces
     
226.     for i in 0...Con::Checker
     
227.       for j in 0...Con::Checker
     
228.         draw_piece(i, j)
     
229.       end
     
230.     end
     
231.     v = judge_winner
     
232.     if v[0] != 0
     
233.       if v[0] != 3
     
234.         @pieces.draw_line(v[1], v[2], v[3], Con::Red)
     
235.       end
     
236.       case v[0]
     
237.       when 1; @msg = "黑方获胜"
     
238.       when 2; @msg = "白方获胜"
     
239.       when 3; @msg = "双方和棋"
     
240.       end
     
241.       @lock = true
     
242.     end
     
243.     @game = true if @pieces_number != 0
     
244.     @sign = false
     
245.   end
     
246.   #--------------------------------------------------------------------------
     
247.   # ● 更新计时器
     
248.   #--------------------------------------------------------------------------
     
249.   def update_time
     
250.     if @pieces_number.even?
     
251.       @game_time[0] += 1
     
252.       @step_time[0] += 1
     
253.     else
     
254.       @game_time[1] += 1
     
255.       @step_time[1] += 1
     
256.     end
     
257.   end
     
258.   #--------------------------------------------------------------------------
     
259.   # ● 绘制棋子
     
260.   #     x：棋子的位置x坐标
     
261.   #     y：棋子的位置y坐标
     
262.   #--------------------------------------------------------------------------
     
263.   def draw_piece(x, y)
     
264.     @pieces.draw_piece(x, y, @table[x, y], @number, @pieces_number)
     
265.   end
     
266.   #--------------------------------------------------------------------------
     
267.   # ● 绘制消息
     
268.   #--------------------------------------------------------------------------
     
269.   def draw_msg
     
270.     @board.draw_msg(@msg)
     
271.   end
     
272.   #--------------------------------------------------------------------------
     
273.   # ● 绘制计时器
     
274.   #--------------------------------------------------------------------------
     
275.   def draw_time
     
276.     @board.draw_time(@game_time, @step_time)
     
277.     if @game_time.include?(Con::Game)
     
278.       i = 0
     
279.       @game_time.each do |j|
     
280.         if j == Con::Game
     
281.           @lock = true
     
282.           @msg = ((i == 1) ? "黑方获胜" : "白方获胜")
     
283.         end
     
284.         i += 1
     
285.       end
     
286.     elsif @step_time.include?(Con::Step)
     
287.       i = 0
     
288.       @step_time.each do |j|
     
289.         if j == Con::Step
     
290.           @lock = true
     
291.           @msg = ((i == 1) ? "黑方获胜" : "白方获胜")
     
292.         end
     
293.         i += 1
     
294.       end
     
295.     end
     
296.   end
     
297.   #--------------------------------------------------------------------------
     
298.   # ● 绘制坐标
     
299.   #--------------------------------------------------------------------------
     
300.   def draw_pos
     
301.     case @pos
     
302.     when 0; @board.draw_pos
     
303.     when 1; @board.clear_pos
     
304.     end
     
305.   end
     
306.   #--------------------------------------------------------------------------
     
307.   # ● 判断胜负
     
308.   #--------------------------------------------------------------------------
     
309.   def judge_winner
     
310.     return [0] if @pieces_number < 9        # 目前没到9个棋子则未决胜负
     
311.     return [3] if @pieces_number == 15 ** 2 # 棋盘下满则和棋
     
312.     for i in 0...Con::Checker
     
313.       for j in 0...Con::Checker
     
314.         if @table[i, j] != 0
     
315.           if i <= Con::Checker - 5                           # 横向
     
316.             for k in 1..4
     
317.               break if @table[i, j].even? != @table[i + k, j].even?
     
318.               break if @table[i + k, j] == 0
     
319.               if k == 4
     
320.                 if @table[i, j].even?
     
321.                   return [2, i, j, 0]
     
322.                 else
     
323.                   return [1, i, j, 0]
     
324.                 end
     
325.               end
     
326.             end
     
327.           end
     
328.           if j <= Con::Checker - 5                           # 纵向
     
329.             for k in 1..4
     
330.               break if @table[i, j].even? != @table[i, j + k].even?
     
331.               break if @table[i, j + k] == 0
     
332.               if k == 4
     
333.                 if @table[i, j].even?
     
334.                   return [2, i, j, 1]
     
335.                 else
     
336.                   return [1, i, j, 1]
     
337.                 end
     
338.               end
     
339.             end
     
340.           end
     
341.           if i >= 4 and j <= Con::Checker - 5                # 左斜向
     
342.             for k in 1..4
     
343.               break if @table[i, j].even? != @table[i - k, j + k].even?
     
344.               break if @table[i - k, j + k] == 0
     
345.               if k == 4
     
346.                 if @table[i, j].even?
     
347.                   return [2, i, j, 2]
     
348.                 else
     
349.                   return [1, i, j, 2]
     
350.                 end
     
351.               end
     
352.             end
     
353.           end
     
354.           if i <= Con::Checker - 5 and j <= Con::Checker - 5 # 右斜向
     
355.             for k in 1..4
     
356.               break if @table[i, j].even? != @table[i + k, j + k].even?
     
357.               break if @table[i + k, j + k] == 0
     
358.               if k == 4
     
359.                 if @table[i, j].even?
     
360.                   return [2, i, j, 3]
     
361.                 else
     
362.                   return [1, i, j, 3]
     
363.                 end
     
364.               end
     
365.             end
     
366.           end
     
367.         end
     
368.       end
     
369.     end
     
370.     return [0]
     
371.   end
     
372.   #--------------------------------------------------------------------------
     
373.   # ● 更新所有精灵
     
374.   #--------------------------------------------------------------------------
     
375.   def update_all_sprites
     
376.     instance_variables.each do |varname|
     
377.       ivar = instance_variable_get(varname)
     
378.       ivar.update if ivar.is_a?(Sprite)
     
379.     end
     
380.   end
     
381. end
     

复制代码

1. #encoding:utf-8
   
2. #==============================================================================
   
3. # ■ Main
   
4. #------------------------------------------------------------------------------
   
5. #   各种定义结束后，从这里开始实际运行。
   
6. #==============================================================================
   
7. 
   
8. Con.run
   

复制代码

第二个

请新建一个工程，游戏名定为《五子棋》，然后删除MAP001，保存并退出，解压此文件并覆盖目录Data\下的Scripts.rvdata2。
Scripts.zip (11.37 KB, 下载次数: 8)

2017-1-29 16:53 上传

点击文件名下载附件
文件：Scripts.rvdata2

第三个

莫名其妙，为什么360会说这个Game.exe有病毒？如果不放心的话，换一个确认无毒的RGSS3的引擎即可。
Gobang.zip (1.34 MB, 下载次数: 29)

2017-1-29 16:57 上传

点击文件名下载附件
文件：Gobang.exe

感谢

@Mr.Jin @Sion

图

恩匹希

作死吧你，我会埋葬的，阿门

guoxiaomi

哇，这个界面好看~为啥楼上会说是作死呢？
我之前也写了个联机的五子棋小游戏：
来自我的新浪博客已弃坑
功能比你这个要少多了……不过可以局域网联机(๑• . •๑)