存放腳本

熊喵酱 · 发表于 2013-8-29 09:01:09

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有帐号？注册会员

x

純屬給LBQ腳本:

=begin #=======================================================================1 Q$ m, b. Y. C& N {
4 Z! ~, k' S/ [3 Q
Sion Mouse System v1.3e
. t- U2 |3 c+ P2 s
& u$ f1 Z% X/ g1 x. t- C: H; C
Changlog7 }) q! F% J) Q; J& P" S4 ^% |' P
/ D1 l% U, i/ _6 ~/ \
2013.4.21 v1.3f
4 u8 f1 P* P6 }1 ?. P
3 K' f! G# K! B4 G+ R: l
1.3f 卷动地图 bug 修正
+ d& k9 p) Z+ z: z' V& X& ]/ w
( I# }) Q5 f. \7 m) Z
1.3e 逻辑优化；提供解除鼠标固定的接口+ |1 ~. M, `2 T
在事件中执行脚本 Mouse.lock_mouse_in_screen 将鼠标锁定在屏幕内
d3 `8 U ]8 S2 ^1 Z& r8 s
Mouse.unlock_mouse_in_screen 解除锁定
, }& Y. C( f) H& Y5 W' A
R# U" e. T- e) x8 t& B
1.3f bug修正
i. E% c9 e7 M( b$ Z q2 O. q: l
9 B/ ^ j) \$ z( F& ?0 M
1.3d 常数设置增加：Menu_Set_Pos，用来设置打开菜单时鼠标是否移动到光标处以及
, \- j% @# m4 s' t/ [
关闭菜单时，鼠标是否移动到原来的位置。0 Y N" p4 o) Y* P
! h' b9 w0 H# C, a2 N3 I3 D
1.3c 打开菜单、光标移动时鼠标会移动到光标位置处
* K1 Y) L! f- u7 J4 w+ {# {
3 g8 s3 u8 H) h2 q; B7 T
1.3b 修正一些罕见的bug；
# e% C( `9 S1 r4 n6 |
, o" ^9 h4 T5 U& [, V8 u
1.3a 代码小修改；6 f! n# c% F3 x# i
加入了鼠标点击启动事件的功能，6 A/ h+ {% T( Y* Q; {9 l3 {/ O. m
在事件中加入“注释”：鼠标启动，
, D: [3 b: B) C# a8 F6 |
该事件将无法用其它方式启动，只能用鼠标左键点击启动。: q2 i) ^2 ?$ }6 I" A( E
& {7 K" e: L0 u7 X( D' |* V
2013.2.12 v1.2# J% z7 p: D& g
) b) ^- ?/ m& `3 w# r* h5 k
寻路逻辑优化；
9 F4 o# i" e5 p8 D
优化了事件判断，现在点击事件附近的格子，移动到指定点后不会触发该事件了； n( Q3 I& s6 b$ \. C
现在支持用鼠标来操作载具了。7 [3 b4 X6 @% ~% `' t y
( ?" U6 x2 @+ ] W" s
2013.2.8 v1.19 O, F. D5 b8 B( S0 Z( e
& ^1 B Y9 u' N( G3 S
优化了事件判断，现在可以方便地启动柜台后面的事件；2 c8 r3 ~. K2 t5 C
修复了某些菜单（例如更换装备的菜单）掉帧的问题；
. t8 i4 U4 G( c: d: T" c. B
移动时，路径指示点的绘制更加稳定；
" t) Z* d3 {* N. {8 |8 G( [
现在支持默认存档画面的鼠标操作了。2 [5 ]# p R5 o/ l
9 z- l9 l+ T: N8 |1 y- ~9 B2 r
* ?1 {$ E1 e& G0 n' [
OrigenVersion' ~% [) k$ ]: i
5 j% d) d4 R; r' A7 n3 I3 \" c
2013.2.7 v1.0 # D$ C7 |/ I& M
2 [9 u$ n5 U: I' |6 t
主要功能3 N. Z9 @8 w7 i, @& d b2 b
5 z. C/ c5 [: Y, C
使用鼠标进行各种操作...
% ?) m c5 O* I) T+ E
将鼠标锁定在游戏窗口内
0 U* l% j# s0 x; } X$ T. p. [7 `" Q
自动寻路，按住 D 键可以扩大寻路的范围5 a/ N5 i1 C2 ~1 |% }! p1 H% o& J
双击鼠标进行冲刺
3 Y( W) I, I7 U( _3 L
更改地图卷动方式以适应鼠标移动9 X, k2 I# g5 f/ v/ v0 B' ]
变量输入框改良3 _5 z/ R% o1 p; @* n* Z$ D7 M
$ d$ Q7 e$ u; n- b
★ 鼠标指针图片 Cursor.png 放入 GraphicsSystem 文件夹
+ C# l- f: V; j% }. J. t
" e- U) X/ I* h) e0 ~1 g! k8 I/ `% L
★ 路径点指示图片 $Arrow.png 放入 GraphicsCharacters 文件夹
* _& w5 Q" m! n) L
6 a5 z( p' a8 G- Y/ L! b3 v. b
★ 如果未放入会弹出提示，并使用RM自带图片代替缺失文件；该提示可以在下面关闭( v! t' J! Z1 h1 S6 k, W9 i
; V0 k. }4 j7 A1 \5 X; K4 S
' M. N( K% d+ t9 l; C. A5 l) `
=end #★★★★★★★★ 可能需要设置的参数都在下面用“★”标出了 ★★★★★★★★★★7 m, u7 V7 o* J: x0 f$ R1 [
Y* N, c$ s! m/ t* B" m: {, |% I
4 L5 q) b2 c' K8 Z1 k
$no_arrowpic_warn = true # ★ 设置为false不弹出图片缺失提示
* a/ Y. s1 o! `' T1 y
- c/ q8 X; h; t3 K7 k
#==============================================================================
' a5 M" r" _" s. U7 l
# ■ 常数设置 7 u( O* p- _1 C v2 N; v p
#==============================================================================
& h" Z6 m% r& Y
module KsOfSion
7 |% }7 `$ r) z" u( C$ R, e5 C
Clip_Cursor = false # ★ 鼠标锁定在游戏窗口内，需要关闭设置为false1 o; c: z- t5 O' \, C L
Dbclick_Frame = 20 # ★ 双击的最大间隔帧数。在地图画面双击进行奔跑
3 C8 z6 l7 } z Y0 r
New_Scroll = false # ★ 更改地图卷动方式，需要关闭设置为false9 J: o* V- n/ u1 n4 t* } k
Map_Scroll_Spd = 1.0 # ★ 更改地图卷动速率，请确保此值为大于0的float变量' G7 R5 C1 P* O
Menu_Set_Pos = true # ★ 打开菜单时将鼠标移动到光标处) ^2 Y$ T& B# [/ |
Break_Steps = 30 # ★ 鼠标寻路最大步数，防止路径太长导致卡帧$ J- b$ s+ e9 B0 s' O1 ^; X
# “30” 是默认显示格子数长（17） + 宽（13）2 m4 C# i5 u) @
Find_Path_Key = Z # ★ 扩大寻路范围至全地图按键 Z 对应 D键
9 o/ @0 q9 ]7 `- g2 z9 O3 s2 p6 s( v
# RM几个内置的空键位 (X = A)(Y = S)(Z = D)
+ x* H) @2 Y* V4 b7 g
end
6 `9 W/ z( ?. C! l1 l( r
; X. ^; U# d+ \% I* G+ p
#==============================================================================
1 @5 s, E! g2 e5 Q& L3 S
# ■ 用来显示路径点的类
! Y; O: o7 q9 \" P! X
#==============================================================================
[# ~+ V, m' ~; {$ W
class Move_Sign Game_Character
7 I8 [- q2 L$ I- |% b3 Q0 r
#--------------------------------------------------------------------------1 C3 C3 U, }1 l2 i) e" M
# ● 设置目标点指示图的各种参数，请注意要使用的图片是行走图
2 k) r( y+ H. q( B( |
#--------------------------------------------------------------------------8 j0 w; n" D- x1 S9 G1 z; J* b; O
def init_public_members8 @6 X5 R2 y' t# Q. L! r% Z
@character_name = '!$Arrow'# ★ 路径点箭头，置于.GraphicsCharacters文件夹1 H. l9 h$ m* b
@character_index = 0 # ★ 图片索引。$开头的行走图设为0. U/ n4 e) E$ W. W( l
@move_speed = 5 # ★ 踏步速度
. S* i6 P/ e+ a6 \( [
@step_anime = true # ★ 踏步动画（如果想使用静态图标就关闭这个）
7 B! w; }' Z- h7 w ~: }" L
[url=home.php?mod=space&uid=316553]@opacity[/url] = 255 # ★ 不透明度6 c/ J1 z7 E _4 w+ ^# c
@blend_type = 0 # ★ 图片合成方式，默认为0（正常）
' H) B3 l0 [ A
@direction = 2 # ★ 朝向，2 4 6 8 分别对应行走图第1 2 3 4 列
# b$ v2 c% u$ F' i
@priority_type = 1 # ★ 优先级（默认与人物同级：1）9 e: E; Z( q9 Y
/ s) x5 ^* ^1 v% ?$ j" ?. _
: h. R5 `, O; [( j
# ★★★★★★★★★★★★★★★ 参数设置完毕 ★★★★★★★★★★★★★★★★★★★9 O6 k8 k' N& Z0 g
# s5 f* o: Z. |& n5 N0 C$ O
) Q4 q: f( m# S+ z8 R
# 如果 $Arrow.png 不在对应的文件夹内，弹出提示，并使用游戏一张内置的行走图
8 q( l- Y5 C$ a! o
unless File.exist('GraphicsCharacters' + @character_name + '.png')" D0 T1 V! M1 K$ M
( k X" T' ?1 j! |
if $no_arrowpic_warn
& Q! U i" N; {( e. }7 e- i
MouseShow_Cursor.call(1)5 F5 b# U: y0 A% y
msgbox('未找到文件：GraphicsCharacters' + @character_name + '.png
) g4 b- n+ h V. x
5 m$ r( J, J/ R/ J1 j
“路径指示点”将使用游戏自带图片6 B% c E6 Z' P% S7 A
( o3 E/ J$ u" }& y
该提示可以在脚本内关闭')
. U3 { g; j! |1 \3 |$ y8 ~6 Q3 `
MouseShow_Cursor.call(0)
* y' k& l9 _$ f. W) X! O7 V9 d
$no_arrowpic_warn = false4 }* w3 {3 X, A% s# x3 r
end0 z7 A. n K4 D9 ]4 p% y& T
@character_name = '!Flame'
, o+ @1 A# X' A2 Q% Q
@character_index = 6
$ N& g4 b' H0 e9 } B; a$ E
- ~% A/ b' Z3 }* P$ @
end% k ^- n7 T# k/ E" D
@direction_fix = false # 固定朝向
+ g# S8 e9 R5 N: ~, d# B% _( t* j! h
@move_frequency = 6 # 移动频率
- o6 I4 ~/ @9 G( N& Y
@walk_anime = true # 步行动画
6 N- F# f6 i t# y+ N6 U/ A1 r
@pattern = 1 # 图案5 o9 U% u6 b6 R H) A
@through = true # 穿透: ^, p6 W" w* L2 U& Y4 E* K* o; ~
@bush_depth = 0 # 草木深度# I" D" P( }; _( `( f
@animation_id = 0 # 动画 ID1 F. h) Z2 n4 |; U
@balloon_id = 0 # 心情 ID
) z* a8 O5 ?5 X/ `; l% h
@transparent = true # 透明
' Q7 E+ A* f6 l' Q, H
@id = 02 N5 e6 l/ l: k& _) R [2 |
@x = 0
& s+ ~- w+ ~9 C2 n- L4 T
@y = 0: K! w9 @& y$ v# b& @
@real_x = 0# W0 Z) y# o" a
@real_y = 09 ]9 a) t2 M h+ ?" [& C# \9 H
@tile_id = 0" L0 u6 \* h( e* S) g( j0 f/ d/ |
end
& G/ _) A5 _/ B. S `
#--------------------------------------------------------------------------' N0 L- ^6 Q5 W4 u2 {
# ● 定义实例变量: O* P3 g+ X: `9 u: k, J
#--------------------------------------------------------------------------! j! w# x9 f5 H' c& {9 X
attr_accessor direction
+ f% _+ p( T/ v. l
end
/ L9 w; B- P$ g; Y0 U4 c
, U2 H! y% g3 }
#==============================================================================
% z5 ~2 N& n9 d! j& C; _
# ■ Module Mouse
+ t& Q8 U5 B2 K, I7 l
#==============================================================================
! B- u; v0 W" D( C" V
module Mouse
# O2 G7 h9 `4 o6 h0 d8 @; b& `
#--------------------------------------------------------------------------2 z0 n' O: @4 v5 ]" |0 U
# ● API& Q7 M7 _2 M' y) ~, x* e
#--------------------------------------------------------------------------
+ E8 j P# X& X u* x) V7 F! H
Show_Cursor = Win32API.new('user32', 'ShowCursor', 'i', 'l')
# d* E/ v" h- ~- y
Get_Cursor_Pos = Win32API.new('user32', 'GetCursorPos', 'p', 'i')3 K, F7 ?+ F/ r; d, Q) w3 e2 n
Set_Cursor_Pos = Win32API.new('user32', 'SetCursorPos', 'ii', 'l')* n% Z+ K' Q+ q2 \
Screen_To_Client = Win32API.new('user32', 'ScreenToClient', 'ip', 'i')
' z" ^0 N& A! J0 d6 [! d
Get_Active_Window = Win32API.new('user32', 'GetActiveWindow', nil, 'l')
7 L6 \1 B1 w- m. ]7 x2 b0 E
Clip_Cursor = Win32API.new('user32', 'ClipCursor', 'p', 'l')& i! B M; a8 |
Get_Key_State = Win32API.new('user32', 'GetKeyState', 'i', 'i')8 \. [) l2 u: U' R4 g+ i
Window_Hwnd = Get_Active_Window.call
# _+ Y% |" w' h. x6 p$ O2 L
6 [6 s" d/ ^/ F- q" ~" H/ H* I! h
class self
1 J, ~; ?+ g5 x: g3 \! m3 u: `
#--------------------------------------------------------------------------
/ @) J X+ f9 g) K: X ]* k7 ?4 _
# ● 初始化7 v' B8 U3 e, z+ s
#--------------------------------------------------------------------------8 K. u! h% F9 t0 ?1 c
def init9 E4 k5 f5 H4 f! ^' {
lock_mouse_in_screen if KsOfSionClip_Cursor! V: U+ d9 O& e. U0 [7 R: G
@left_state = 09 I4 y- K9 I) h
@right_state = 0
! l- Y* f; i, T/ ?
@ck_count = 0 # 帧数计，单击以后从0开始, ?( b+ w J7 K6 ~& W
@dk_count = 0 # 用于双击的判定) j, J* X% H' }, g: V% {+ V
@clicked = false
8 ?# Z n6 Z' I, c% j8 l: D
creat_mouse_sprite) t, J0 c" @3 k6 ~* t+ @6 g
update
- E7 N# A; N8 L1 @* s
end
. V+ b9 }6 n! x& o8 p a, ?
#--------------------------------------------------------------------------- W6 h/ z' d9 E+ S
# ● 鼠标指针精灵
9 m* g/ G. K2 _. D
#--------------------------------------------------------------------------
2 Q P. G( D5 N( h' `
#~ def creat_mouse_sprite
6 ~0 I5 S }3 ^ d7 l& z
#~ $ m Q- ?' H2 s7 M: X
#~ @mouse_sprite = Sprite.new
! s, P8 E T( u8 Z
#~ panda = 2#rand(2)+1
* K5 x }2 I7 K4 t+ K5 y
" A; M) |1 L C; `" h1 H8 a
#~ if panda = 1
8 \) s8 t' x; _5 Q; Z; b
#~ if File.exist('GraphicsSystemCursor2.png')
: i) `/ M# X+ D& B1 I
#~ @mouse_sprite.bitmap = Bitmap.new('GraphicsSystemCursor2')9 X; r; \; `# R9 V9 Y7 y
#~ end#with if File.exist8 g) Y; Z" E% `, h, S8 c9 n
#~ ; s+ E! J! z1 D$ g0 h3 R0 e5 U
#~ else if panda = 2 #with if panda=1. x. n% j+ l; t% p2 ^2 n
#~ 2 a. V$ e/ P( V8 M0 X2 C9 [( l
#~ if File.exist('GraphicsSystemCursor2.png')
7 }: T2 u4 |( ]1 `% d; a( Z2 U
#~ @mouse_sprite.bitmap = Bitmap.new('GraphicsSystemCursor2')
: O7 q. b: ^. V2 n+ Q+ M. Q5 a9 t
#~ end#with if File.exist0 z4 S7 T) R" r, S' w
#~ 4 Q4 r$ f1 [1 y
#~ else #with if panda=14 I+ a% p3 i. D) O
#~ @mouse_sprite.bitmap = Bitmap.new(24, 24)
+ I3 H- H; l( N6 |
#~ @mouse_sprite.bitmap.blt(0, 0, Cache.system('Iconset'),, K% `8 O8 d9 j
#~ Rect.new(5 24, 24 24, 24, 24)). Y2 F% k3 S2 u4 Q% A! e3 E% H" h
#~ end#with if panda=1
J. S# k2 ^1 M, _# `
#~ 1 x- X2 Y( p6 p" ^
#~ #with def- `, Y( E2 q b5 G9 B$ C( M
#~ end1 k' Q9 l. s! s
def creat_mouse_sprite$ k: i$ m+ h5 x. f
@mouse_sprite = Sprite.new* g, {7 P5 }7 w- v
@mouse_sprite.bitmap = Bitmap.new(GraphicsSystemCursor#{rand(2)+1})
: h) B2 @0 x* z- O
@mouse_sprite.z = 9999
$ k3 r# B5 K4 O" k
Show_Cursor.call(0)% P' i; G$ l2 p9 ~
end8 v; U3 @& z5 \# j4 L* Q* _
9 H- B) f: i4 i* x+ p
#--------------------------------------------------------------------------; g+ V* j6 X9 s+ D
# ● 更新/ _ P& h0 W" L- |& J7 S2 w- G8 V
#--------------------------------------------------------------------------
8 I/ e) E- f! `: p2 I! K- a& H( a
def update
" Z; U% Z% K" @' ]
@mouse_sprite.x, @mouse_sprite.y = get_mouse_pos
% |4 e3 o! E" ^; I' X
left_state = Get_Key_State.call(0x01)
7 c* M. t8 n. W0 {7 Q2 O" L
left_state[7] == 1 @left_state +=1 @left_state = 02 n6 m7 h$ I+ m8 X7 p" X* R6 ~
right_state = Get_Key_State.call(0x02)
+ e' B1 t8 `# E8 ^+ }
right_state[7] == 1 @right_state +=1 @right_state = 03 }( W- p' H$ L4 s2 H
update_double_click+ m+ u7 j) a3 g! J1 B8 u
@left_state == 1 @ck_count = 0 @ck_count += 1) c8 |6 \1 J- P2 f. [
end6 C: `5 @6 g" x9 C7 s$ U; D
#--------------------------------------------------------------------------
! K8 [; }' W! b+ [
# ● 获取鼠标坐标$ ^$ G" U2 j; E- x$ p& {! t
#--------------------------------------------------------------------------4 B7 q! K) D% ~+ `; |& |
def get_mouse_pos
, ~7 B$ U' q7 j5 r7 {$ {
arg = [0, 0].pack('ll')' m& D; e2 R# L- I
Get_Cursor_Pos.call(arg)
. @0 A. U+ Y3 U' ^# p% p3 N
Screen_To_Client.call(Window_Hwnd, arg)9 J! W. F- G5 s, f
x, y = arg.unpack('ll')
8 D2 Z$ z8 _7 q) O% n* F
return x, y
2 h6 p% n1 j) I9 p+ d2 m' j
end4 X8 K1 H8 `/ c Y) Y e, W
#--------------------------------------------------------------------------
. e+ I7 G V. e& O
# ● 将鼠标固定在屏幕内
7 g, H& e$ s7 e9 W" j9 z' m/ @3 m
#--------------------------------------------------------------------------) s, C% K' n3 I3 _5 i. ?
def lock_mouse_in_screen: O: I; O, R/ X
arg = [0, 0].pack('ll')
9 m( r' D- F5 Z9 P: ^& b8 k
Screen_To_Client.call(Window_Hwnd, arg)& n ?$ ~" i# W2 ^: D. h0 f
x, y = arg.unpack('ll')
) D0 n6 Z; L/ ]& z F7 u$ }
Clip_Cursor.call([-x, -y, Graphics.width-x, Graphics.height-y].pack('llll'))) r9 x2 Z) S0 x* k1 l
end
- B3 I3 `/ C! p! T$ D- d$ a( @% T
#--------------------------------------------------------------------------
4 j6 b& r1 W B
# ● 解除鼠标固定
0 ^, z3 D- y9 ]" j2 C
#--------------------------------------------------------------------------5 y5 e5 C3 |1 R& T
def unlock_mouse_in_screen; Z7 z# \5 ~1 s% E2 z' |
Clip_Cursor.call(0)4 j ?) a: i9 |0 l* g( ^
end2 J! m B5 u4 g; q/ @+ r* l
#--------------------------------------------------------------------------
/ a0 W, q0 t7 |% B
# ● 鼠标双击判定
; I6 ]4 L3 h, t7 n5 ]
#--------------------------------------------------------------------------
9 s" K$ @+ Z9 Q( U, b
def update_double_click( L% O+ }; R; i$ k. o3 I& S
@clicked = true if @left_state == 1
( j. v; P7 l) M* z5 i' X+ Z
if @dk_count 0 && @left_state == 1
7 i- R1 ?" A' f. F
@dk_count = 0; @clicked = false
3 M E! t4 F8 q5 p" T7 e* z8 C2 C
return @double_click = true
# ~) r3 F3 W8 s+ ~
elsif @clicked4 B* c: o: ]! t3 q! u1 g
if @dk_count KsOfSionDbclick_Frame
" e/ e* C C) A% `8 q( M2 V
@dk_count += 1, E1 a% d( ^" f; R
else
. S9 M( d4 u% l2 P& Y
@dk_count = 0; @clicked = false# W- k% G$ }, ~/ t
end
! L- x5 V3 Z* \ a+ @
end
" p, E d }3 p3 r
@double_click = false
* R0 X8 M. W+ z
end- f# S; a2 U; T. @
#--------------------------------------------------------------------------& G- g3 \7 M: ~# K" c% m8 E! f. J
# ● 按键被按下就返回true) i R' h* N& k# H0 o
#--------------------------------------------------------------------------# X2 p+ G* V# O
def press(button)8 y' p: k; D2 R3 s& ?
case button
# R2 u" \' P, h" z
when 0x01; return !@left_state.zero
7 V( J6 U4 c3 [4 x! @
when 0x02; return !@right_state.zero0 ~% O% S9 `+ c( K, r3 J% p6 V$ O/ b
end
9 L8 J( y3 g W; S4 ^- s$ d
return false
( Z2 @6 j' e1 @/ J& G* B
end
! M' H' m& {+ t: [
#--------------------------------------------------------------------------) Q4 [4 [+ M! t! J+ V
# ● 按键刚被按下则返回true
" A$ n! }: ^% i" c) r
#--------------------------------------------------------------------------) q9 V$ B- W4 ]! r; Z0 o* \
def trigger(button)* ]$ R5 V9 Y2 q+ d1 J4 L
case button3 O. Z3 T, ?. x( t3 r! U
when 0x01; return @left_state == 16 v! u F7 j0 c7 @0 B+ i
when 0x02; return @right_state == 1, j1 Z0 d6 V# |! \* e5 M
end% q% _" r/ o" p4 f+ K& V/ {$ D
return false
3 s, W: `' x7 i4 L
end
/ l0 V( U. `5 Z# j( ~5 S
#--------------------------------------------------------------------------
5 B) S! [# C5 C. a, o) S
# ● 持续按住键一段时间的话，每隔5帧返回一次true4 N! b/ K3 N: }* [9 b. @; u
#--------------------------------------------------------------------------* E9 i4 y# Y! N+ w( ^2 i
def repeat(button)/ R7 k! ]" a7 l$ h
case button7 a: O8 v; K* a. s: D8 s4 _$ Z- h
when 0x01; return @left_state == 1 + @( K* i) ~# Z' K6 R
(@left_state 22 && (@left_state % 6).zero)% y& R, n- \% u* w6 F
when 0x02; return @right_state == 1 3 _8 n5 v/ `0 q) @' K( C6 L
(@right_state 22 && (@right_state % 6).zero)/ U) G5 E. J1 q
end
/ v; t, O t; {" V' j" J) @2 Q
return false3 P; R8 L8 V* r! c2 F4 x7 L3 O
end
; P g) d0 ? J I1 l
#--------------------------------------------------------------------------& C6 l. F. u3 A! y
# ● 判断是否双击鼠标
1 Y, S2 s1 H6 F+ ^8 m
#--------------------------------------------------------------------------4 L6 X% p# r- D1 ~. {$ A t
def double_click
& B: [9 }: h; d3 o i4 A: f8 ]
@double_click7 y: P( Z& @2 Q5 Q3 F
end: u/ F' f! R8 N% Y4 s: U
#-------------------------------------------------------------------------- L$ [2 y8 Z. n; Y
# ● 获取@ck_count（每一帧+=1，单击后重置为0）
2 l8 G* `$ E7 W/ F. m& H6 j( \
#--------------------------------------------------------------------------
8 D5 Q7 P' N: Q3 O
def click_count
# S6 I' J, B$ R$ n- I% a' U
@ck_count9 {0 x/ x( s+ l! k' L. B" J6 d# v
end
$ w7 B* Z+ ]0 L7 j7 I
#--------------------------------------------------------------------------3 }' O; E& Y4 D+ m' {
# ● 获取@left_state（按住左键每一帧+=1）
) Z* ~4 h7 s2 K4 g8 @. q
#--------------------------------------------------------------------------) s6 f% n! ~6 B
def left_state( S4 H% B" @% D$ r
@left_state" z, F1 U$ U4 q7 C `+ `4 }
end
9 i/ R# O4 |+ L3 ?
#--------------------------------------------------------------------------
. w/ _: f7 g6 \3 k- l
# ● 获取鼠标的x坐标
, m! x( p$ p7 H/ t7 [( S# x: o
#--------------------------------------------------------------------------" x0 L3 {! c3 _- v& [4 j. c
def mouse_x! q' D! i) o+ }: q4 L
@mouse_sprite.x P6 f+ S6 m s+ a5 C( B N' J
end+ o+ G4 ^+ i; D/ l$ _4 \9 p9 D; E' J
#--------------------------------------------------------------------------+ U+ U5 {5 H- X7 e+ W
# ● 获取鼠标的y坐标/ r ?# t& E3 _& l2 o/ t. U! S2 X
#--------------------------------------------------------------------------
4 j# q8 P- e$ m3 `2 W
def mouse_y; }; o7 Z7 D; N% s) s0 [3 T6 o& |' k5 v
@mouse_sprite.y
* K% X% e. ^- L- S
end4 ~& [2 w7 M1 [. k
#--------------------------------------------------------------------------8 L) f' X, @/ n& |: w" @
# ● 设置鼠标坐标: C( l' x2 J8 p8 W* j: J, S
#--------------------------------------------------------------------------$ `9 ?/ y! e6 N' v+ y" I z
def set_mouse_pos(new_x, new_y)! j/ Q8 {4 C3 O
arg = [0, 0].pack('ll')
; w: S4 T2 o" }/ P6 x& f, {
Screen_To_Client.call(Window_Hwnd, arg)* z. M. r8 l+ }- e5 c: W, R
x, y = arg.unpack('ll')
) Q2 v' x9 H. H& O q* H
Set_Cursor_Pos.call(new_x - x, new_y - y)
3 S7 t+ _* S0 p3 V
end
$ @0 } _7 T( N2 K! M/ A
end #end of class self
( m1 S: V# ~; Z) Y8 |
' H0 W/ H3 ?3 M2 ]/ B
end. K1 `# C# J- T1 L
& v# ~% U6 p/ A$ `
#============================================================================== b' M6 H3 r6 ~6 |9 }/ W
# ■ SceneManager
# {* j* R% f6 \1 A, }/ j. T1 r
#==============================================================================3 U9 M5 z3 C8 e3 x7 I. t
class SceneManager, l% |3 p8 o+ D1 t
#--------------------------------------------------------------------------
p& ~ q0 j$ L
# ● alias
1 b0 v, |, }7 q- h
#--------------------------------------------------------------------------9 q( o) Z% m# U+ G6 b# T
unless self.method_defined(sion_mouse_run)$ N0 [7 W8 v: ?1 U5 e# I* g' s
alias_method sion_mouse_run, run: B) k( P& c6 U+ ?5 ]. l% f+ o
alias_method sion_mouse_call, call
& D7 O* U7 y! g/ W0 f% u
alias_method sion_mouse_return, return
* ~" j/ f7 _! E! e7 j6 d$ }
end0 K1 b/ n7 X. S
#--------------------------------------------------------------------------+ o! |; x4 x+ b& M9 X0 ]8 i* t0 E% C
# ● 运行0 V& y7 q& U6 `# J, p0 ~
#--------------------------------------------------------------------------
* U% k5 Y" @ y! C# l: p
def run2 k* Q' _& i4 U& q( r+ d4 K
Mouse.init$ \; g9 H1 \. _2 x( G, q, @/ R8 g
sion_mouse_run& f; ^- ~6 D( \# M' `
end
9 x2 d) v) [ j' R7 g, W s: r
#--------------------------------------------------------------------------
9 Q/ r% e& B. X) @9 g3 ]
# ● 切换
+ p2 e' q* c/ V; \9 \9 `5 M
#--------------------------------------------------------------------------
9 e' O& r6 |( {9 ]3 P @+ d
def call(scene_class)
5 i( n* }7 x5 B# J* Y* K
$game_map.prepare_reset_mouse_pos if @scene.instance_of(Scene_Map)
0 d6 V8 v* ~% Q# F$ c
sion_mouse_call(scene_class)
+ G1 i3 v# Z O: g$ M
end! c! o- T8 t) F0 D
#--------------------------------------------------------------------------
0 L) X% h6 s0 {! s
# ● 返回到上一个场景
" ?; Y. v: s& F, l
#--------------------------------------------------------------------------1 M( X. z7 `7 o
def return
3 \/ v: B) u6 r3 \; V
sion_mouse_return
3 G6 b$ e0 T' Y
$game_map.reset_mouse_pos if KsOfSionMenu_Set_Pos &&( @) p4 {0 Y9 {8 }4 ^* z5 V& p- p/ K( @
@scene.instance_of(Scene_Map)3 y& u& k+ y& s* [$ P% `' ~
end, }6 o) A6 f# y5 f& A
end2 r* m0 ?9 z5 ?" @/ j+ V
5 {9 Q ~7 v0 q7 w; V* w7 C
#==============================================================================! @% ~5 D' l4 v9 Y, B4 [9 y8 p
# ■ Module Input
' }! C: K' ]: L+ Z
#==============================================================================
* z; A' i, d6 \' U, Q# I- t" h2 [( i
class Input- \6 A e/ j6 ?
#-------------------------------------------------------------------------- }+ T: T9 K/ v" M! D. _) l
# ● alias6 t# f$ C! X/ p
#--------------------------------------------------------------------------
- a$ O4 Q l6 H8 i: a' G5 X* ]
unless self.method_defined(sion_mouse_update)$ C4 X% W: _% i& D( p* F) X
alias_method sion_mouse_update, update
% x0 E- g9 X, W1 Y$ @- N7 [' x
alias_method sion_mouse_press, press0 d: `$ Q) h" q" h& Z" \' U6 i
alias_method sion_mouse_trigger, trigger
2 V$ _2 G/ y, v: e* F' W% \4 K! }' a
alias_method sion_mouse_repeat, repeat
: u+ v! c" b: H5 B1 S& N
end
7 u& `; o# }# Z
#--------------------------------------------------------------------------
) y$ c: a# h2 A: j
# ● 更新鼠标# c: y0 l0 ]) v% M$ M/ e5 ~, a
#--------------------------------------------------------------------------
! {2 B1 T* ^; u x
def update
4 F2 m9 M S6 f
Mouse.update( t6 E& e, n% q; o9 T6 q0 B1 ]
sion_mouse_update- c1 O) t* z: v, c
end3 \. t# p! ]# a+ X$ y/ Y8 _6 i
#--------------------------------------------------------------------------0 ?$ c8 C4 L5 j+ z
# ● 按键被按下就返回true3 T* x7 r4 d- f/ s" F+ B
#-------------------------------------------------------------------------- B0 i1 w* @; `7 t' @
def press(key)) c$ e4 f5 U) S; l- c' t9 {
return true if sion_mouse_press(key)
" ~9 l/ ]7 O) p. P" ^+ Y9 U
return Mouse.press(0x01) if key == C
! q0 T5 ~: x/ Y. J* S3 k
return Mouse.press(0x02) if key == B7 R ~8 V5 M6 o, E
return false
' `( U& v! Q3 p' b ^7 L) ^* c
end
, ?( U0 n6 D$ j& {
#--------------------------------------------------------------------------
6 h4 i5 W; g, u1 J; q/ e
# ● 按键刚被按下则返回true& n( p/ b: o% C' T* v e `
#--------------------------------------------------------------------------
+ o& U2 J t; F9 g
def trigger(key)3 L2 N1 o; n+ V: {3 R
return true if sion_mouse_trigger(key)# X* G ~- c: ^7 \$ F5 u2 O
return Mouse.trigger(0x01) if key == C
; r. E' B9 I* m7 W) \9 c6 z
return Mouse.trigger(0x02) if key == B
( D% ~9 c9 ~( k" }$ c
return false2 k4 h$ S9 f* I+ ~# o/ Q6 @$ X
end+ i: D8 X7 W: x: {/ b+ \, Q2 s; b
#--------------------------------------------------------------------------
8 ~) A' u# M Q5 j# E+ h- B
# ● 持续按住键一段时间的话，每隔5帧返回一次true! i4 `* c. [3 s3 ^9 P8 [
#--------------------------------------------------------------------------
& Y& {; Z. H& l2 }. h
def repeat(key)
t6 x( Y& c/ c& L% R3 u/ n
return true if sion_mouse_repeat(key)
k, i0 }5 [, R# ?% V/ m
return Mouse.repeat(0x01) if key == C3 X! a4 G7 [8 k, j( K
return Mouse.repeat(0x02) if key == B
( ?2 g" \: r0 C! U( r& _
return false
# E8 ]; w, J U: A+ e
end
/ u+ M' ?1 N9 U: D) H& d4 Y, G
end
! b- ~$ g8 _5 d) }
; L( `2 b/ u/ q) J
# O) S0 l% C$ u/ `( ~# `8 {
#==============================================================================
! k* }0 R4 I( X; `' x0 X8 D6 i9 ^
# ■ Window_Selectable
+ c* o) ~0 A) ?/ a& n8 a- n
#------------------------------------------------------------------------------4 q$ n- U% ` y& C, Q
# 　拥有光标移动、滚动功能的窗口) |% o: M+ P& k' S9 a' M
#==============================================================================
; Q+ ~! u* i" Z0 g
class Window_Selectable: P7 o3 p. v5 B2 n% d: ]
#--------------------------------------------------------------------------# h: ]) | H' v* x7 y5 k5 z6 Z
# ● 初始化
. y4 w- B0 @: E1 a2 ?
#--------------------------------------------------------------------------# {) {+ Y" W5 x3 f* n5 x
alias sion_mouse_initialize initialize2 R9 ~! i. Q4 a' W; f1 _: E( I0 @
def initialize(x, y, width, height)
+ J8 P/ a T$ C7 ^% L6 H% R* S
sion_mouse_initialize(x, y, width, height)
0 c! I/ f/ E" I: I! M8 M: r( T0 p
@move_state = 0
( E. c& U# ]; F2 a$ {+ q; ` `9 |
end
! r1 W+ \1 F9 M6 { G. M& K
#--------------------------------------------------------------------------
L2 L3 \$ r- A, p: ^6 R# F- l
# ● 更新; {) |5 x. Z3 @ M# A6 b) M9 }
#--------------------------------------------------------------------------0 K8 H5 |; a& J0 k/ V
alias sion_mouse_update update- ?, F& v5 J* s) q) J& G
def update
# p2 |0 \& ?. O) s4 ~ n
sion_mouse_update
1 R \, h Q2 g' g' a ]' x9 Z+ A
update_mouse_cursor0 @$ M) J- l p& c: W% T
end
5 n5 W/ I5 {+ u0 Q4 W- h
#--------------------------------------------------------------------------8 p9 C( D' _, A3 C3 F' A8 Z
# ● 启动后设置鼠标到index位置! H/ Z( y- J( y! I7 f2 e
#--------------------------------------------------------------------------
! I* y2 M4 H1 J" y: P0 N
def activate. A9 g6 G% ~# P
@need_set_pos = true if KsOfSionMenu_Set_Pos
3 L5 h# g* U1 \, p
super
9 [6 ~- ?# m8 q% j0 o0 s) P
end
7 S% {+ @7 c* c( V/ K
#--------------------------------------------------------------------------1 x* y( f) f% S- y) o t7 v# t& n0 H
# ● 更新鼠标和光标的位置+ R. p( |( u) A; @0 O5 P
#--------------------------------------------------------------------------& E/ D7 R7 d7 \7 H$ n5 `: A
def update_mouse_cursor
! z9 H8 \9 A. h' l1 [
if active
% l, [7 n4 w3 B' ~" F3 g1 o# Q
if @need_set_pos+ n0 ]/ X2 [; ~8 @: N
@need_set_pos = nil5 u. C+ W: \7 V2 I2 D/ q
set_mouse_pos
1 \4 C }' m0 E9 Y) J4 x! k) b9 H2 D
elsif cursor_movable" b9 B* f! ]: G0 m. `3 C! B' K
Input.dir4.zero set_cursor set_mouse_pos8 t8 _# L) q# A0 g
end: S. h+ P' U: H/ t5 @+ O1 y# x
end
" k9 r0 ?9 Y' i/ I" f
end. y4 L5 Z# [6 t
#--------------------------------------------------------------------------- q, L6 {% n' Q& H) ]9 F
# ● 将光标设置到鼠标所在的位置，附带卷动菜单的功能' F# N* {' O$ V
#--------------------------------------------------------------------------3 t( r) Y4 U/ ]+ M) y% U# B0 l3 i
def set_cursor# M8 h5 i( c/ O3 g
mouse_row, mouse_col = mouse_window_area8 U7 s' `- {8 ^
if mouse_row == -17 g) x- }. h2 G& ^8 \9 {# C
@move_state += 1 if need_scroll& C4 B& A- J3 F
cursor_up if (@move_state - 1) % 4 == 0 && !is_horzcommand
5 V) f( p% G7 }- O8 |
elsif mouse_row == -2
5 N" M% |$ V4 B) |
@move_state += 1 if need_scroll
cursor_down if (@move_state - 1) % 4 == 0 && !is_horzcommand
% K% T* |8 ]/ s
elsif mouse_col == -1
0 X( {$ m: v0 l ~4 y" K' Q
@move_state += 1 if need_scroll4 } [: x1 `# C- w' b1 ?
cursor_left if (@move_state - 1) % 16 == 0 && is_horzcommand
0 K7 r+ T, S; l6 A- ]
elsif mouse_col == -26 y3 `4 I/ b5 I1 [, I
@move_state += 1 if need_scroll/ Q- ]' n3 R) B. s* e% J. u0 @. [
cursor_right if (@move_state - 1) % 16 == 0 && is_horzcommand
x5 p" _6 y. ?
else- L+ I% z, |& ~' H( o3 w% Y* y
@move_state = 0! N; s9 ~6 D% r
new_index = (top_row + mouse_row) col_max + mouse_col% {, |" l: p0 J8 K2 r1 ^
select(new_index) if new_index item_max && new_index != @index
4 w, G" G- C1 O$ }
end7 P; ]% ]/ [' Y O* p6 K% d
end
* P( Y. o" P, H5 [
#--------------------------------------------------------------------------
9 `+ o* g! a, t7 D" u
# ● 判断鼠标位于菜单的第几行、第几列
. h B1 D% L9 L* Q' y+ c# {
#--------------------------------------------------------------------------: ^8 o5 m2 i6 w
def mouse_window_area
7 D; p# }# ^! X; h
if viewport.nil # necessary!
0 Q+ E: k) ^* W$ v
vp_x, vp_y = 0, 06 R; \0 F5 F. ~
else% G, Z7 b8 g: Y- E7 U' l
vp_x = viewport.rect.x - viewport.ox
/ ]" T' Y+ z. v! E w
vp_y = viewport.rect.y - viewport.oy8 G7 Q0 q/ \3 w- J
end0 t/ b0 g; t% F, M3 u
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y
; g4 C# [7 {# D$ t5 a O
item_x1 = vp_x + x + standard_padding
( N, y3 c! C& m; I" @
item_y1 = vp_y + y + standard_padding3 z9 u* r! x3 ~+ f5 v
item_x2 = vp_x + x - standard_padding + width% `6 j/ S- H! \3 S( i. h- A( M
item_y2 = vp_y + y - standard_padding + height
y( W6 V2 P% x) H; d6 x) G4 G
if mouse_x item_x1) \9 Y6 J2 q B
mouse_col = -11 b- R5 t3 }7 ~7 E' `2 Z
elsif mouse_x item_x2
6 `) t; ~$ h* H S7 S& `8 o
mouse_col = -28 l" F, c$ Z& \7 B! N& k
else) h* s O- o4 M& q+ `* s& y, n1 d
mouse_col = col_max (mouse_x - item_x1) (item_x2 - item_x1)
5 P1 b# z' J5 F$ q K
end, C: Q: P' o! ?; T$ W
if mouse_y item_y1
! H5 l$ Y# `" }5 v& p
mouse_row = -1
d3 a& |! p$ H t3 i
elsif mouse_y item_y2$ j* R( t; J. e* E& A8 l3 |0 |
mouse_row = -28 e5 N' Q- W" B& U ^% |& e5 }
else2 O$ X" y4 s! s" t( O% _. E
mouse_row = page_row_max (mouse_y - item_y1 - 1) (item_y2 - item_y1)
4 s3 U/ m+ d% i" E
end
) b; X+ [0 v0 {/ Z- s3 D! L: g
return mouse_row, mouse_col& d3 { j# l8 L$ X {% z
end
( v. V- j$ f* s7 ~" Z; P" y6 r# ~3 f
#--------------------------------------------------------------------------% r& b5 g9 C* r f p" C
# ● 方向键移动光标时将鼠标移动到对应的光标位置$ D% x$ w, @" u3 f6 m. @5 k6 V
#--------------------------------------------------------------------------4 t* e) B2 k2 L6 e# v* R
def set_mouse_pos0 I0 L5 \. {% g5 z$ o
if viewport.nil # necessary!
$ ] T" E" H; T( {! X% F, }% x
vp_x, vp_y = 0, 0! q# I& d" N x) h/ c. r- @
else$ A% H) b" j B
vp_x = viewport.rect.x - viewport.ox8 ? ]! l5 F2 |9 H/ D
vp_y = viewport.rect.y - viewport.oy
3 D1 F5 ]0 z3 K: C- J4 r- ]' Q, z
end6 P0 J5 x( X* T. ?' g6 k& B; T
item_x1 = vp_x + x + standard_padding ! G: n% W J5 Q: {' \( Z
item_y1 = vp_y + y + standard_padding
3 D9 b$ n. P, a. H
get_index = [url=home.php?mod=space&uid=370741]@Index[/url] 0 0 @index
' X6 j8 ~5 C+ I3 {7 i
row = get_index col_max - top_row2 c$ E6 e9 Z. ]- I
col = get_index % col_max
( Z: {7 o9 R: ?0 v0 u- D
new_x = item_x1 + item_width (col + 0.5)0 l1 \7 ?5 ^# o, l: z; B, u
new_y = item_y1 + item_height (row + 0.5)
+ c6 \+ Q9 Z+ _* _. y8 L' w
Mouse.set_mouse_pos(new_x, new_y)
; X; a+ t8 Y4 g: i
end
" L# m- {! V( o
#--------------------------------------------------------------------------
5 q/ V( W R- ] J+ l n/ y
# ● 判断菜单是否需要卷动
; h& G n' k( z5 r! \
#--------------------------------------------------------------------------
. t' `4 [% Z* i3 o3 H- |" F
def need_scroll
. c& c7 n: P" E' C; N- n7 `5 D
item_max col_max page_row_max
& e8 F' R+ m1 N4 y, e* c" Z0 z% a
end" o) |+ l" x7 L9 k% C
#--------------------------------------------------------------------------# R% q& k: ^! m7 f* X
# ● 判断是否为水平卷动菜单
2 x4 S2 I7 @8 G% t' w8 c, Q
#--------------------------------------------------------------------------
! Q; D2 x! w" y* e, u+ H
def is_horzcommand
6 g) ~+ V P- q+ w
return false2 Q8 Y, X5 E7 V Z G, w
end
! {" R3 }2 m$ J& l
end
, k5 h5 q0 q: m ]) l# ~
( ?6 W/ N1 }( [
class Window_HorzCommand1 Q) [4 O: ]/ T( W/ I
#--------------------------------------------------------------------------3 ~2 e4 F$ T$ D7 q% j5 e) r
# ● 判断是否为水平卷动菜单
4 M4 x$ X: R. N7 [% t* B
#--------------------------------------------------------------------------4 J; J- |7 [7 D' A- D- U J& Y
def is_horzcommand" `5 A6 C5 L' {6 F
return true
0 H Q6 C- b5 v/ l' T: @4 [$ f: A( M
end: l4 g- Q7 e/ L4 O7 B/ C0 n6 ^$ e
end
. M: f9 T( ^& Z# r7 N
0 v# Z: f9 \, |% i0 b
#==============================================================================
+ r# w: X: q; a
# ■ Window_NameInput
0 w( V& o0 K$ B s6 H1 Z$ W0 {
#------------------------------------------------------------------------------' p I5 Y7 h* l, c* v
# 　名字输入画面中，选择文字的窗口。
; W5 R) R% l. O2 h
#============================================================================== L% t( S. f/ n2 m
class Window_NameInput
3 a! c& T( h- o/ y9 v, ^* ?* q# M
#--------------------------------------------------------------------------% Z9 x. o! q" E1 p' J' |
# ● 设置列数
s }; e2 {$ G* n4 L4 B
#--------------------------------------------------------------------------" z d( c$ L D4 [" d$ _+ W
def col_max# a# D+ e' v( m1 Z
return 10
7 z9 ~/ H: N+ V; Q
end
( |- v! F5 r9 n! z
#--------------------------------------------------------------------------
2 P1 t8 L4 E" |
# ● 设置填充的Item个数
* \. z) l/ k( s( m
#--------------------------------------------------------------------------) A) `5 k1 P: y. r
def item_max
( [, i9 d9 c; V) v
return 900 C G: `( P. U# b. H$ t" c. h& w
end1 f2 ~9 y) f$ Q+ f. Y8 u6 I9 }. R5 g; n
#--------------------------------------------------------------------------, {) I- _) e7 n0 g. Q+ G5 X K
# ● 设置填充的Item个数
, g/ f' y. W, ]* ^) e
#--------------------------------------------------------------------------
& z4 Q6 i: @* n | }5 e0 Z" m
def item_width
. _: q3 Y _4 t }7 L7 b- o; X% T
return 32
9 p `; h- \: Y# H9 j# T, I+ ~
end
& h. D6 G/ l7 ^% g4 o
#--------------------------------------------------------------------------
W; u8 R6 z+ j5 J$ @5 L" ^
# ● 判断鼠标位于菜单的第几行、第几列
' t+ M1 L) Z; m0 X# Z
#--------------------------------------------------------------------------
0 a Y4 ]1 D! s' V6 U$ h( p- N
def mouse_window_area
V9 I+ M# E" J% @
if viewport.nil
! r' {: b* c# B; L5 D5 Y
vp_x, vp_y = 0, 0
! }5 m& ~6 @2 U5 r6 W% v% G, ^
else% i+ g4 i: E2 {" F( q9 r% U
vp_x = viewport.rect.x - viewport.ox$ p# c, \9 i/ i7 \' [ Y* w" e
vp_y = viewport.rect.y - viewport.oy: a% d* k! b& C, g
end
: v+ x$ _3 n/ N" _' L8 {; {' R9 f
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y0 R1 q8 z g7 E/ W* W! |
item_x1 = vp_x + x + standard_padding
& n+ u! p& ~+ L1 S" {
item_y1 = vp_y + y + standard_padding
5 l0 k O" o. h! j. r8 s
item_x2 = vp_x + x - standard_padding + width3 V' Y1 @, w4 P8 z/ }0 D' i
item_y2 = vp_y + y - standard_padding + height
+ k9 F$ S+ Z7 t* Q3 N
if mouse_x item_x1( L, }, w) d4 ^; u$ D' D
mouse_col = -10 {. h. _) P% w' t, t7 p
elsif mouse_x item_x2
3 |2 l' F/ ?$ D: y
mouse_col = -2
* u( V- L5 A% n7 v! M
elsif mouse_x item_x1 + 160) B5 ^4 v+ {- @% _7 S7 R! c
mouse_col = (mouse_x - item_x1)32
: O8 z% `' q2 E( Y; z
elsif mouse_x item_x2 - 160+ W0 V; j% B( M& c
mouse_col = 9 - (item_x2 - mouse_x)323 x/ @: }2 p5 e7 c% I
else
$ e4 ]9 f/ p5 M8 O6 j; a
mouse_col = mouse_x x + width2 5 4 ?4 f* Q$ N3 d. }7 h1 x" B, R' H
end
( W b- C& k; l7 z* G9 B
if mouse_y item_y11 I# n6 Y* J" f) @( q! j
mouse_row = -17 }8 o* ?8 a$ |9 Y' z# v4 E
elsif mouse_y item_y2
0 R6 H, Y& `, G, A' w
mouse_row = -2* C( q- @0 D1 m8 F! z, {- ]
else
9 u# R+ e5 n+ r
mouse_row = page_row_max (mouse_y - item_y1 - 1)(item_y2 - item_y1)' |- _2 w4 g F5 W* \
end& ~: g8 Q# y8 x( \0 x _! q9 U0 f
return mouse_row, mouse_col5 r, O. c' j* G" S X
end" u6 w' Z6 m7 t5 \( W9 Q
#--------------------------------------------------------------------------# d- D/ y( v# \7 R' v& r
# ● 方向键移动光标时将鼠标移动到对应的光标位置
/ @3 C" [" ?# N5 G( l
#--------------------------------------------------------------------------
; y% J( T* A: r% P" a8 V
def set_mouse_pos. b& I& _! Q- C
if viewport.nil # necessary!$ K* w8 z* d; z# c) d% U9 i1 T' I
vp_x, vp_y = 0, 0
- F2 \1 V& K! x9 G7 K
else6 V0 t% U5 Y4 E) f
vp_x = viewport.rect.x - viewport.ox6 X4 [; V8 Y+ J2 G
vp_y = viewport.rect.y - viewport.oy; Y( i- l3 R# x& }0 n5 A$ p/ u! ^
end
3 ?* M- F; y- z! O
item_x1 = vp_x + x + standard_padding 0 b% Q2 }$ c9 A. n
item_y1 = vp_y + y + standard_padding
! \# t* Z1 [8 L6 S. p2 q; a
get_index = @index 0 0 @index
/ l. Z& E, L$ r% o+ O+ U9 D4 f- m
row = get_index col_max - top_row
^1 L; ^! k, a
col = get_index % col_max! f* x# P0 S) M1 b0 ^6 E
new_x = item_x1 + item_width (col + 0.5)7 b! }' x6 Q- k9 H/ M; z
new_y = item_y1 + item_height (row + 0.5)
5 c" y& b5 W5 B3 l& I$ E
new_x += 14 if col 43 @5 W& w ^/ d( |
Mouse.set_mouse_pos(new_x, new_y)
! j* D8 L" M5 Q0 O7 |+ [
end- d( f' h* C7 o$ W. y
end E4 }9 b8 y% B0 O. O
- r0 W* J9 {5 ]: ]
#==============================================================================
4 O* I7 w0 h# r, x1 t
# ■ Window_NumberInput4 F+ D4 ^& a6 N1 x
#------------------------------------------------------------------------------
1 c% L2 G( G8 k0 a& b
# 　重写了数值输入的方法以适应鼠标
' Q/ Z! R# f f& o. B4 }
#==============================================================================+ {) B! G* Z' j
class Window_NumberInput Window_Base9 _0 f# @8 p5 _9 m- u8 R
#--------------------------------------------------------------------------( n/ k, ?3 E2 e7 U1 u
# ● 定义实例变量
. G; r' Y* m% }. V
#--------------------------------------------------------------------------
* t7 E4 i/ s4 A" d9 K% g' D
attr_reader extra_window
0 A. \/ B8 N" `" Y% a
#--------------------------------------------------------------------------! ]% M6 K, D" g# }5 S
# ● 初始化4 e& n- c; ^6 U% [ e0 X
#--------------------------------------------------------------------------( U9 O, u8 W: J" Y* u6 y$ K
alias sion_mouse_initialize initialize
: c3 x! f ~, V6 _+ H( L. C
def initialize(arg)
7 q+ X' g( h+ M6 J( D' F2 s
sion_mouse_initialize(arg)3 T* U+ B. t* }! p9 @& d
create_extra_window
) M( c" s, Q7 V& `: i& n/ t: P
end9 h' U' f. Y1 P- ^$ o' J; e
#--------------------------------------------------------------------------) h- W" A" O0 X& w* o3 H. y+ Y
# ● 启动! o/ r3 _7 v9 d3 V1 I& q
#--------------------------------------------------------------------------9 {+ D: ~5 J0 D- y. k% L) @2 _
alias sion_mouse_start start3 i# z* W9 y; ]/ ~7 V# }: H
def start' B! _+ f) \) ~0 l' N, x
sion_mouse_start! y: D2 t# _& L. |( E
deactivate. f, ?! s* X A2 K2 M |3 h
extra_start
5 l& G) v. u2 b0 \
end
( x# M; W' g! @4 m3 p2 n
#--------------------------------------------------------------------------. p3 R; @) D2 p
# ● 创建新的数值输入窗口
E5 |7 t) l- l+ l) L, W0 i2 S3 n
#--------------------------------------------------------------------------
0 v9 |- t' f* `/ o: ?. T2 M& _
def create_extra_window
6 X1 [/ y! s- b
@extra_window = Window_NumberInput_Ex.new! a; E$ g4 }& E" U9 B
@extra_window.x = (Graphics.width - @extra_window.width) 2
. B* r, R- B) h( D
@extra_window.number_proc = Proc.new {n [url=home.php?mod=space&uid=27178]@Number[/url] = n }
0 C5 R7 y- d# u+ X5 b
@extra_window.index_proc = Proc.new {n @index = n }3 u5 f9 D2 E# i3 W) B' l8 K
@extra_window.close_proc = Proc.new { close }
; `9 S+ v2 t* w8 k' U2 f
@extra_window.refresh_proc = Proc.new { refresh }
. Q; c, H c+ U" I5 m" A
end' ^9 ?9 a( {- ?; l+ S
#--------------------------------------------------------------------------) [3 E! M3 \/ N+ O+ E
# ● 激活新窗口
, N. |" }7 L6 i' S2 f" F
#--------------------------------------------------------------------------
, l' @* L* v1 N1 ~) O% u
def extra_start
1 [' s( u7 n; \+ k8 T9 q' m
case $game_message.position/ E6 V* h/ c) o. r
when 0; @extra_window.y = y + height + 4( C t# O1 L3 _& X
when 1; @extra_window.y = @message_window.y - @extra_window.height - 8
; a. C+ l# u8 T# @( X& I
when 2; @extra_window.y = y - @extra_window.height - 4
: Q5 V$ {7 j8 V3 S% N% `
else ; @extra_window.y = 83 k# r- j$ c% l6 G% l( y; L# g6 h
end
7 H8 x0 z$ [( l3 C; y. A
@extra_window.variable_id = $game_message.num_input_variable_id
/ M8 x% Y2 v' a0 W3 p3 T
@extra_window.digits_max = @digits_max' N/ q) n6 ^; k" G6 x
@extra_window.number = @number4 U2 s, r. O2 O( x- n) x4 J3 f
@extra_window.open: y) F7 C# ~, l( V3 n$ v, \
@extra_window.activate
( p2 \) R1 m( F0 @' ]/ d9 Q
end
9 \5 l3 w( v4 ?+ P- l
#--------------------------------------------------------------------------
- f! G% Q! K# q; P. V
# ● 更新. J, L# \" M1 x3 N
#--------------------------------------------------------------------------
; M5 E* d2 I8 {' j) `
def update
+ Z: o: G. q! I, Z2 Y2 q+ O+ [$ i
super
4 l: `4 G* h( Y2 G- W
@extra_window.update
" j( B* B3 S. E
update_cursor
3 v- ?0 R* ^/ i6 Z' l
end
9 K# c- h. J2 L: j9 p0 }4 p3 A* w
#--------------------------------------------------------------------------* D. g, M( m2 M7 w
# ● 关闭窗口! E! a; e, Q: \
#--------------------------------------------------------------------------6 `) I) |9 `1 J5 l0 p' T- R
def close! k, M; b3 m' S3 D4 f' b4 R' o
super
- |- e$ H% r1 F" C$ l B
@extra_window.close
, n. [! m$ l' ?, ^; h4 y
@extra_window.deactivate
% C* a0 _6 z4 {* C
end2 U% d( \% T0 o' {1 M2 |
end2 N' Q# H0 V$ N, j* M% d
9 l6 @6 n0 E9 [
#==============================================================================
/ x$ X6 B1 g+ N( E" ^
# ■ Window_NumberInput_Ex) f( A3 ?; p; T* ^& z
#------------------------------------------------------------------------------
- g% r/ i' `( ~2 W' |
# 　新的数值输入窗口(NewClass)
+ b4 W" z2 T$ E
#==============================================================================
) |7 k) s# ]; H
class Window_NumberInput_Ex Window_Selectable
' Z5 F; S1 {0 C
#--------------------------------------------------------------------------! v7 t. |% X+ {, b
# ● 定义实例变量 J) P# C) |1 {) j
#--------------------------------------------------------------------------1 Y0 k4 Z I) d4 F
attr_accessor number_proc! i# k2 {: }7 f1 l8 y# ~
attr_accessor index_proc' v4 w; Q; B* b: \ X# k
attr_accessor close_proc% H' s k' m* ^, U5 F
attr_accessor refresh_proc6 D% C% K y9 h( t* V: w
attr_accessor number" V6 I# @- \8 O- V, Z" a! E+ S( T
attr_accessor digits_max1 A6 L( |8 V8 _% `5 f9 g! {. b
attr_accessor variable_id+ [# z* }, L/ O/ t
#--------------------------------------------------------------------------
. ]# a( B- D6 o( R3 T
# ● 数字表
" S5 {2 ]4 Q' w0 i* x! v
#--------------------------------------------------------------------------
. N; a% w3 _, Q% E: ?4 l
TABLE = [ 7, 8, 9,: ?0 Q, I! K2 I/ ?$ _7 d% f+ |# a
4, 5, 6,4 o% m9 ]( i" z: o g
1, 2, 3,
; l7 ~: S% _/ X1 g# K5 e
'←',0,'确定',]
- h2 S' ~9 w' u# y
#--------------------------------------------------------------------------. N# |! r y5 ]- v1 o9 W1 [( {9 Z
# ● 初始化对象# z. n' ^( H( E. i/ `6 R
#--------------------------------------------------------------------------
5 S* m' n- l' i0 d; ^
def initialize7 y5 r0 v) K+ W: o4 v
super(0, 0, 120, fitting_height(4))
0 e5 C4 W/ l c2 B
self.openness = 05 W6 D8 K9 |/ \
@index = 0
8 w7 q2 p7 a" W6 O& {* d# @
@number = 0* C9 ^1 _8 ?8 C, s) U$ ]
@old_window_index = 00 t1 X/ C- a* J
@digits_max = 0: E9 J u% B6 }- i
12.times {i draw_text(item_rect(i), TABLE[i], 1) }& P1 m' m! I9 V) _5 v
end8 Q! V: z h, U6 a0 y% [3 V0 \
#--------------------------------------------------------------------------5 ^( u# ~, s1 ~' p. |8 W9 x
# ● 获取项目的绘制矩形8 Q7 S2 R# O$ B5 i% k+ B
#--------------------------------------------------------------------------
W- `% ^ T1 ~; m+ J. }1 D* Y
def item_rect(index)
8 q: I$ K4 r8 S: _8 U3 q1 B
rect = Rect.new$ H8 ?# O: B# _* \7 z; ]
rect.x = index % 3 32
" I3 U( U' y( E9 h
rect.y = index 3 line_height u1 h' @3 Q7 \) ?% p
rect.width = 32: o1 P7 B! X* u, A/ y' b3 c
rect.height = line_height- I( z+ Y) U- W/ e
return rect
end# f+ E: x D+ j, J, M
#--------------------------------------------------------------------------
/ u+ |7 [1 l2 L$ K
# ● 将光标设置到鼠标所在的位置/ S$ c! K9 \. E" A
#--------------------------------------------------------------------------% ]' \; A" _5 |8 |
def set_cursor/ k+ N+ ]& R! T: e, U; U3 V
mouse_row, mouse_col = mouse_window_area
$ s" O) E, R( r4 T" r) r
if mouse_row = 0 && mouse_col = 0
6 r6 M& V7 b1 X3 J; h
new_index = mouse_row 3 + mouse_col, @& M/ P2 F* l9 t* j- f# z
select(new_index) if new_index = 11
( ?/ p8 {, U/ P% H/ O
end
! | i$ S; F3 d' A5 }% d
end6 T. J% W; x& \- }
#--------------------------------------------------------------------------
# F! U* d# i, D5 N5 t7 E/ u- I0 Y
# ● 判断鼠标位于新数值输入窗口的第几行、第几列
2 s+ n1 t, d4 V0 v1 i9 e" S
#--------------------------------------------------------------------------
' K( a8 @7 _' W, U0 S! J+ c* w
def mouse_window_area; X: I: E( |! o5 W* E, C" J( c
if viewport.nil; b& B9 [0 e; X
vp_x, vp_y = 0, 0" X* o4 g4 [, D, T/ p4 C" I
else
3 p; N. a. S8 i9 b* r3 P L
vp_x = viewport.rect.x - viewport.ox
0 S K& U9 s7 K
vp_y = viewport.rect.y - viewport.oy. |" n8 R& k0 _! V. U) U; z2 a& N
end1 u1 k6 u# |8 N4 I% \* m N" d
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y7 v! E6 ?- L4 N2 x) z4 m
item_x1 = vp_x + x + standard_padding 2 ^7 @: `" s" q+ j- I* U
item_y1 = vp_y + y + standard_padding
% ?- B; k! |7 Z' y
item_x2 = vp_x + x - standard_padding + width
4 j; v4 m, j5 `2 S% |
item_y2 = vp_y + y - standard_padding + height
, ]4 w/ @1 W x
if mouse_x item_x1
( ~* P3 J" J4 g* u E
mouse_col = -1( v0 T6 Y' H& @. w# c( c
elsif mouse_x item_x23 E" M: G; q+ l9 w) M; O$ |7 h+ R
mouse_col = -2
2 I4 N. V$ V2 T# M0 }
else
; N* h' C0 l" R; O1 Z
mouse_col = (mouse_x - item_x1) 32
$ k" p F2 Q' N+ J& |+ b
end
$ f. K7 X' Y* m, Z& f
if mouse_y item_y1
& L2 ]7 [5 D) s B _5 r: z
mouse_row = -1
8 q9 f. U4 {$ _( U
elsif mouse_y item_y2
1 h. H Y# M0 I! M) P
mouse_row = -2
0 N% Y, @ |: l; g' Q0 R
else
^ a1 y6 }# {* u& \) H
mouse_row = 4 (mouse_y - item_y1 - 1) (item_y2 - item_y1)7 _& p% t7 w( v# q% @
end
! S f3 h+ I6 C8 @& ]1 m
return mouse_row, mouse_col
, o) S$ W1 Y" z$ \7 h
end
% y9 P& U3 g- J
#--------------------------------------------------------------------------
8 }, h7 o4 g- s
# ● 获取文字
8 [; L% w! m$ R0 k) v
#--------------------------------------------------------------------------
- c& `) @! p0 O8 {, y
def get_number
0 V" k. ]7 ]! A5 m
return false if @index == 9 @index == 118 E4 q2 d0 V! v9 s# L! n
return TABLE[@index]
" {7 V) |2 f$ A# x0 c. H9 B6 U
end
. r: ^$ i! i5 K% f( t/ x
#--------------------------------------------------------------------------5 S* e* O( U% R3 C9 d$ m
# ● 判定光标位置是否在“退格”上* d4 r4 u5 I/ A+ n0 `, J
#--------------------------------------------------------------------------, \5 A5 E" G B1 S! H
def is_delete- Z! W1 U) }1 K2 V; p
@index == 9
. Z* ?6 x2 ]" N- P+ n! ?! Y
end
; @* `8 o! R& J2 B/ `7 u0 n
#--------------------------------------------------------------------------; q6 k* E/ u& a
# ● 判定光标位置是否在“确定”上* T4 m, `+ j2 u) v$ ~* P
#--------------------------------------------------------------------------
U. J9 W; c6 t1 N2 _1 D
def is_ok
2 Y) A* T. _2 m; F
@index == 11
) I# z6 _4 [ ^- d/ k6 a6 Y+ w9 K
end
- K4 E( ]- C0 s2 N
#-------------------------------------------------------------------------- D* m5 T l3 n* }, N v0 O* s
# ● 更新光标& A# N, B* Z4 ]% _) O0 a+ y6 L) o
#--------------------------------------------------------------------------
/ z* W+ \2 Q S5 m9 t; v
def update_cursor
( L4 n% |. K( z9 ^7 @
cursor_rect.set(item_rect(@index))( V: M: Q( C$ y! _# d
end% t/ E: ^/ B I
#--------------------------------------------------------------------------9 b" Z3 q7 a# O1 P$ x* v7 ?
# ● 判定光标是否可以移动% o5 g# E) Y* l3 z- s+ G9 C
#--------------------------------------------------------------------------" |+ s2 ]# W+ z7 A
def cursor_movable0 j5 M+ U: g3 U3 G2 j4 m
active- v8 j* R' M+ p* L
end3 l" l6 i( L0 Z- v
#--------------------------------------------------------------------------
. e& H+ V2 V( |& ?
# ● 光标向下移动! b$ b( p. _4 k7 F' E
# wrap 允许循环: y) ?& \" B: u& Z7 T. L
#--------------------------------------------------------------------------
( P5 C3 F# R4 V. u; h
def cursor_down(wrap)
1 k8 Y/ x9 k$ F; J: D' ?
if @index 9 or wrap
& ^; V" Q& `! J) t0 {$ m N% g
@index = (index + 3) % 12
8 i# u* ^8 T! L; `
end
, d W. k M8 m6 U& N6 [" B2 k
end
( b$ x) B7 j# c' V& B0 F7 _
#--------------------------------------------------------------------------
9 P: R C& t8 J, o: ~4 i' h7 K
# ● 光标向上移动
- H2 S& e( Q; }3 H
# wrap 允许循环
# w" H( w+ Z: M0 ?. k8 [1 v
#--------------------------------------------------------------------------2 {% E5 l2 L+ n
def cursor_up(wrap)! [( V2 d/ N Z& B" G; T
if @index = 3 or wrap. j) P) M: P0 q
@index = (index + 9) % 12; _$ p% u# I: l* f
end
: G2 E2 ?$ O# R/ f
end i0 L' b$ c5 j' X4 u) p& W% n) W
#--------------------------------------------------------------------------" s# d; m- F9 k5 w- c3 {# i/ h
# ● 光标向右移动7 F6 g- u+ \) t+ K0 c. {, `
# wrap 允许循环
$ `, ^3 J2 r$ S& a z
#--------------------------------------------------------------------------* J1 z/ w/ A N2 r+ h9 \; O7 Y% R
def cursor_right(wrap)) w4 h! |0 ?) Z' u& i3 o/ L2 q
if @index % 3 2! c8 {) h; g* R5 B- U
@index += 1, ]+ h$ W# }8 O. D7 i6 c/ r
elsif wrap
" D$ b& o( g- o! P+ T* B7 ~
@index -= 2
0 N& i" o5 L( P5 A4 L9 r' \7 I
end$ U* \# w8 Q- _- Y9 f# E4 Q
end
% U, i2 m1 i. Q. ^% d
#--------------------------------------------------------------------------& x! ?1 ]$ P5 `9 j! g- a! w9 F7 I
# ● 光标向左移动
$ P8 W. C5 l0 ^7 j f$ w
# wrap 允许循环# t3 ?7 e: M$ X2 r4 I" b e7 ^- A
#--------------------------------------------------------------------------6 F! y" w, w; X* t3 ~4 U. Y
def cursor_left(wrap)
( d4 J( u. K( f- H# f
if @index % 3 0- R* l+ H. b1 l8 I
@index -= 1
& N( @' G; P7 }7 Z7 O! |* F" h
elsif wrap4 W7 a: v- G, v+ e ^
@index += 2- O$ f2 I; w4 e# M
end
1 }' [; M% ~; |
end
+ J+ E- @' V# l
#--------------------------------------------------------------------------! b4 J& ?% y7 |$ M+ w8 k
# ● 处理光标的移动, ?4 ^- u' _; G U
#--------------------------------------------------------------------------% A! R# j& u2 m0 c. @
def process_cursor_move( J% M5 Y/ I5 E) `
super
: K5 I. b" z" Z$ P
update_cursor) h& d g; u+ \7 e& y7 w: v
end" S0 W" ` H0 E1 m& }
#--------------------------------------------------------------------------
5 o- \ w- ]7 J2 u6 {" p. k
# ● “确定”、“删除字符”和“取消输入”的处理3 t4 n% y' E Q1 ?7 m
#--------------------------------------------------------------------------
( ~' l8 G: _& O7 Q' ]
def process_handling- Y& Y% Z0 A" A* W
return unless open && active
5 ~+ m5 k( G0 f/ c1 P
process_jump if Input.trigger(A)
' m- {: n! u& ?5 M$ s
process_back if Input.repeat(B)* ] f8 o& l% t$ L- d* W0 z. v
process_ok if Input.trigger(C)9 G! S8 ?/ I, ]* P0 ` ?
end( h# ]* _: D: {
#--------------------------------------------------------------------------
, \ O B" u4 Y& L
# ● 跳转“确定”
/ N/ C8 v2 l% R7 x
#--------------------------------------------------------------------------
# r3 k% y+ `; _
def process_jump; F: T- L% h" B$ W
if @index != 11
$ O1 {/ g% d& f. p i" Z
@index = 11
$ J- Z. h" ]' c1 H' J
Sound.play_cursor3 b/ u0 `/ Z+ A% `; g9 y+ I
end
4 H* }/ P3 b! A
end% O$ j$ \* w. b8 }( e/ x& r' v
#--------------------------------------------------------------------------0 `- g4 y& s/ D3 l# Y# y$ k
# ● 后退一个字符 }% I' z+ B; n. y/ M$ |& p
#--------------------------------------------------------------------------
% J( M% ~6 x% o$ s# Y
def process_back# }* A1 Z I; u& D# ~2 } N" T3 I7 b1 s
Sound.play_cancel
- M$ h/ H1 T; C
place = 10 (@digits_max - 1 - @old_window_index)6 Y) ^- b' g. C6 `% s3 {$ ~
n = (@number place) % 10
& }# H6 v. V4 `! D( H1 H
@number -= n place
; h# B g9 W$ |
@number_proc.call(@number). L! k% E" X- S, z; h0 U# x
@old_window_index -= 1 if @old_window_index 0
8 J6 y* U( M# T( a0 o9 \& u
@index_proc.call(@old_window_index); r; z' c4 S% \9 B' V
@refresh_proc.call
9 j X, G1 t% f$ |
end+ H% {' d! @; f# j
#--------------------------------------------------------------------------
' w+ R8 k& ^% I0 V, v
# ● 按下确定键时的处理
3 y& y! w! P: m, |; |
#--------------------------------------------------------------------------. h; Y* T5 t' w4 T! n8 l8 y- s# f
def process_ok0 L/ U0 O4 M, a8 E" W) p9 X; k5 C
if get_number2 u. [$ l- m+ N, F# s. k
Sound.play_cursor/ T! Q# o7 P2 z% Q* W; `
place = 10 (@digits_max - 1 - @old_window_index)
# p1 F/ \$ j7 _" U& V$ K" V$ a
n = get_number - (@number place) % 10 S+ v. b! d7 j% s# i% Y7 C
@number += n place1 s5 P6 u" O! ]/ I& |8 V& |/ G
@number_proc.call(@number)
; V+ D7 p5 Y5 q4 K. L
@old_window_index += 1 if @old_window_index @digits_max - 1
: _5 t' L9 [9 c
@index_proc.call(@old_window_index)
/ |) [% o: d9 O" D
@refresh_proc.call
4 i& W K& ?+ N0 ?9 i: X
elsif is_delete
6 M- v7 o8 a1 D" X
process_back$ {/ t3 |; T" T! N! r3 {0 W/ L
elsif is_ok
+ S2 x6 x# Q5 E- `
on_input_ok
- x7 O% D& a& Z! C
end' ]8 c- g9 C7 G' M
end
% j/ k2 x; C: S7 C7 h" `$ m
#--------------------------------------------------------------------------
$ J1 a0 s& ^, {# p# J
# ● 确定* |2 e% x2 n1 y' ]
#--------------------------------------------------------------------------, v8 R E5 \7 l' Y, \# A
def on_input_ok
- d3 B7 n2 `; v: X" e- ^
@index = 0
) b/ [) I/ h0 @1 {
@old_window_index = 0, A9 F' q# H: D
$game_variables[@variable_id] = @number* B$ N0 d) V0 z2 m( R2 ]& E' }
Sound.play_ok/ X+ q4 n- M9 P
@close_proc.call
8 `; _& g8 b7 }2 H, |$ b
end0 u- W$ p. J. C4 k! l$ R( i9 y& ]
#--------------------------------------------------------------------------
% U I+ x9 ]2 J
# ● 方向键移动光标时将鼠标移动到对应的光标位置 R- i8 i; { Z
#--------------------------------------------------------------------------: P" y8 r' ?6 N E/ g/ q/ B
def set_mouse_pos6 @3 A7 ?1 O# c" P& A
if viewport.nil # necessary!5 F% j/ F5 s5 y! B/ @
vp_x, vp_y = 0, 0
5 p1 V" n' h& }! P
else
* A4 D9 F; ~- }
vp_x = viewport.rect.x - viewport.ox; ]* z$ O. H- j: O7 P# U
vp_y = viewport.rect.y - viewport.oy& C9 K+ d' p5 S3 n- C# K# E+ P
end6 |/ Z" x% M$ {: j$ d6 d/ A
item_x1 = vp_x + x + standard_padding 4 x/ q% `" s% [ M+ ^" Q& C% a
item_y1 = vp_y + y + standard_padding
4 M7 x* t, }5 x1 p8 O
get_index = @index 0 0 @index + R" a @. I) ~: Z% D! c7 D
new_x = item_x1 + 32 (get_index % 3 + 0.5)- p, Y# F( @, }4 r+ U0 W
new_y = item_y1 + 24 (get_index 3 + 0.5)
( y2 M1 z* \* W3 n4 O
Mouse.set_mouse_pos(new_x, new_y)5 F4 c* |, f1 B1 t2 `. \
end
! b+ K' }0 o- m; Q
end
" w2 ]) v, G1 X. M9 s
D i" N% _, F7 W- \" Y
#==============================================================================
0 H. r9 H& t; o5 w- H
# ■ Window_Message$ z9 q! w4 i$ E6 s4 C4 ]% J$ T' r
#------------------------------------------------------------------------------
1 W' z1 F. F4 E P1 X/ L* [; u
# 　显示文字信息的窗口。& J* L( R$ e2 Q5 F/ e# H6 A% d
#==============================================================================
class Window_Message Window_Base( q* b! Q7 g# g, j# l
#-------------------------------------------------------------------------- \& ?6 v& C; }% {2 G% G
# ● 处理数值的输入（覆盖原方法）& m" W0 Z$ s; T" D! @9 t
#--------------------------------------------------------------------------
x" {- ]: e8 D
def input_number/ t! f6 p9 \! L3 T$ S& H; n
@number_window.start- `2 z. U3 C7 ~0 [) D
Fiber.yield while @number_window.extra_window.active
6 x( u- r; y. m7 U# ^8 F
end
+ }! q3 D0 ?( d1 o5 ` ?5 z; s0 e
end" ~6 t$ l" _0 ~0 W0 h0 a! {
4 d- R' X2 Y9 y( e1 L. \5 T" o
#==============================================================================
& j6 D# v2 J1 S5 R' |3 W) m( h
# ■ Window_PartyCommand l( H& I4 G4 |- S0 k: T0 q. M; P
#------------------------------------------------------------------------------
% C+ q4 L: Y) ^% `1 \( g2 j0 o+ U
# 　战斗画面中，选择“战斗／撤退”的窗口。3 _6 l% }# d$ x3 ]/ G1 y9 H
#==============================================================================
" K* a* l# { U0 E3 x
class Window_PartyCommand Window_Command
; P8 N" q- D5 w' S# I4 I! X
#--------------------------------------------------------------------------$ W0 r. K6 u8 Q+ r0 w
# ● 方向键移动光标时将鼠标移动到对应的光标位置0 E- L' F7 E) m4 t! w$ F3 r7 J% p
#--------------------------------------------------------------------------
, j5 t7 l# E0 ~, n% \0 [# b
def set_mouse_pos
; G0 P2 L* ^* j- o4 ~
if viewport.nil
% ~+ @9 ?0 h; {- I: U1 l8 c
vp_x, vp_y = 0, 0- V: j6 O6 ] \: Y% {1 t/ M3 N
else
5 b% B# a# k. Q' s
#vp_x = viewport.rect.x - viewport.ox: k& @) m Y6 ~1 ?. I4 Q) F
vp_y = viewport.rect.y - viewport.oy
1 w. k1 R& w: |% P
end, a5 v% {1 l2 R% j% P
item_x1 = x + standard_padding
; L2 c, P2 \2 w! f3 t; C2 Y8 R
item_y1 = vp_y + y + standard_padding
$ j; W* w! U. Q1 L( N% d* D
get_index = @index 0 0 @index
! J7 ^& I# s7 f- |4 Z# j
row = get_index col_max - top_row" X6 |8 i& r& I. F1 t
col = get_index % col_max; \7 R# _4 h0 H8 V
new_x = item_x1 + item_width (col + 0.5)
( n+ i S ]* d# `' ~ g4 [& E
new_y = item_y1 + item_height (row + 0.5). k+ S; ^% X$ O
Mouse.set_mouse_pos(new_x, new_y). a1 U0 {' a! }2 f( }" w
end' S+ g2 t& h+ i: X' |
end
& n0 a5 k* E; |$ m/ Z$ z Y% H
$ Q3 h& q5 D H8 S
#==============================================================================
/ q1 G$ W* W: `# u
# ■ Window_ActorCommand
# C2 h5 n4 o8 b
#------------------------------------------------------------------------------0 ~0 B2 M. R0 J( G3 d
# 　战斗画面中，选择角色行动的窗口。- K9 s0 t' w. F0 `4 r
#==============================================================================9 U) A8 [3 t, v' h
class Window_ActorCommand Window_Command
- |6 Z. h1 q$ R2 N6 M
#--------------------------------------------------------------------------
4 t" Q- g% u( n7 }6 {# t
# ● 方向键移动光标时将鼠标移动到对应的光标位置+ J8 g3 A8 f" p7 _- {! D
#--------------------------------------------------------------------------2 @+ s0 t d8 K: C# H1 n
def set_mouse_pos
+ R- M0 G8 F7 G! H& x/ u/ {
if viewport.nil; d8 n' g+ s% S
vp_x, vp_y = 0, 0
$ P5 `& |2 J( ^" Z- O- j
else
t& l! m+ b; `' k- m6 w' k
#vp_x = viewport.rect.x - viewport.ox1 q/ P, y. [# E
vp_y = viewport.rect.y - viewport.oy+ q; s3 W9 W2 B' r7 Z6 y
end4 U/ i6 \, D* A4 z" O2 H
item_x1 = Graphics.width - width + standard_padding
% d6 h. f6 A$ ?5 X# o2 }( E
item_y1 = vp_y + y + standard_padding
: m5 i% c0 Q+ _
get_index = @index 0 0 @index
5 m& A/ h/ ^/ Q9 R7 v( C# A$ K/ t) {
row = get_index col_max - top_row
Z7 p+ \ `5 B* V: v+ ?
col = get_index % col_max
5 L/ s- |$ v6 Z2 L0 ~9 ?/ K9 y! u
new_x = item_x1 + item_width (col + 0.5)
& L" L5 B) J- x+ A3 r
new_y = item_y1 + item_height (row + 0.5)
. E( K C) k% `4 ?
Mouse.set_mouse_pos(new_x, new_y)
0 g0 [# y( Q& _9 i0 n' b* O
end
# W1 ^, y& n& c% O, I2 f
end
' v- u4 y+ Z# a& I6 X% ?5 l
% J8 k% V/ c* I4 }) p$ x" e
#==============================================================================9 l! F% W3 C! B9 c' B
# ■ Game_Player6 K* i8 H3 ?% k* O, D- G, O
#------------------------------------------------------------------------------
% ^! g/ ~7 h+ w6 ~, k! y- T L
# 　处理玩家人物的类。拥有事件启动的判定、地图的卷动等功能。, x `8 |$ ]% h1 v
# 本类的实例请参考 $game_player 。) c; y5 M' J( B! ~; X& T
#==============================================================================
T# J5 `4 \' T8 V% o: j! C. f; a
class Game_Player Game_Character
( E0 h- i+ S* y5 n
#--------------------------------------------------------------------------
, I1 r8 N$ D$ ]) Y, p
# ● 由方向移动（覆盖原方法）' o& {! p3 Y9 z9 [) e
#--------------------------------------------------------------------------
6 {* S0 j" O9 B! U& r4 d% O9 ^
def move_by_input9 u- a8 B: s( E6 W0 U( B/ n
return if !movable $game_map.interpreter.running+ e- M1 ^8 K- u! S
if Input.dir4 0
" G2 j+ X5 B7 u/ u
move_straight(Input.dir4) 8 S" s8 G- v& D& t% O8 A+ ]) H! s( g
reset_move_path0 k0 ]. o0 J, Q$ L/ ]
else- K/ {2 H+ l& \$ n" o$ E& o
move_by_mouse
7 y6 x; `0 \- s
end
$ W3 Z4 u E! @* X$ z9 o
end* z9 r5 \) [$ U8 ] G& y/ Q! y
#--------------------------------------------------------------------------- F4 \1 ~. f/ A5 k* B
# ● 非移动中的处理（覆盖原方法）+ H' r9 @1 m l* Q7 F. p/ S
# last_moving 此前是否正在移动! E* t& d J/ H
#--------------------------------------------------------------------------
8 w* B% w" c9 z s- A
def update_nonmoving(last_moving)" @1 _. z+ J1 T$ y# J
return if $game_map.interpreter.running
& h4 j+ E3 J# J: f* f$ s7 I7 Y- n
if last_moving
- F4 w+ A9 S2 u/ p
$game_party.on_player_walk
. h) N6 l$ |3 K5 a' i* S' a2 c
return if check_touch_event
' `4 c1 Y, {) K. v- x
end6 B1 a L2 W5 A; ]4 y* q" U) M
if movable && Input.trigger(C)
* b, I g. o0 ]9 ~/ l
return if Mouse.press(0x01) # 防止按下鼠标左键绘制路径时触发事件或载具切换
- S0 R! ^$ \. Z8 L( F" G1 k- e# _
return if get_on_off_vehicle! _0 O& a* x% r
return if check_action_event: i4 u! ]6 ~/ l
end
0 m$ C7 w! A/ p0 Y, e) t) G8 z
update_encounter if last_moving" @* Y5 i. O6 X+ ]
end' O, q: c+ a. R7 u
#--------------------------------------------------------------------------, C2 X2 Y* W& D: V4 |' U
# ● 判定是否跑步状态（覆盖原方法）
% ?8 ]1 [; l6 {! _8 o
#--------------------------------------------------------------------------( o; M" O% U- f! }2 O
def dash
* l7 H! J) j' b1 \5 {' x& x7 s; A
return false if @move_route_forcing
4 D7 s- f9 x3 [7 _- H. S
return false if $game_map.disable_dash9 j5 T, ]. q9 k7 ` Z- Y: w
return false if vehicle1 w# b; G) N$ H9 d5 c
return Input.press(A) @mouse_dash
3 e6 t* m! ~( k8 m! Q
end2 s6 y) X# P3 X2 k0 a. p
#--------------------------------------------------------------------------9 g0 g) R, e; b& F* D
# ● 初始化/ G$ s9 P0 z8 C; ~) h) d
#--------------------------------------------------------------------------
k, v3 u& Y3 @9 ]) p# x" e* v
alias sion_mouse_initialize initialize
% ^' [( U- T% }2 T6 l% P3 t" X
def initialize2 `. m+ A* ~' F2 f- D1 I7 C% R# i
sion_mouse_initialize
/ L1 T! W( j+ T2 [- r3 L6 q
reset_move_path
$ A3 g; s8 k b4 t
@moveto_x = 0% R. @5 B e, a
@moveto_y = 0
end
! _% j/ c& j5 I. S: Q+ c
#--------------------------------------------------------------------------
) V0 a, R+ k- T P$ Z+ B' _7 L' i
# ● 更新7 b/ x( `& W% b" q; s4 a/ _
#--------------------------------------------------------------------------1 G( P- h% g ?8 W4 K/ j; \
alias sion_mouse_update update
8 R6 p& |* e5 x& E' M
def update) U" @8 d6 i5 E2 D. K7 n' V
sion_mouse_update; e! s% r: ]' m3 f# o* i) {7 y/ N
clear_unreachable_sign# M S! X6 B1 F9 R
end/ E& X. J! q. D% X9 p5 r
#--------------------------------------------------------------------------2 d" l* q% `! W1 T1 v! A
# ● 处理卷动
& v0 ]; T; m8 o5 e( g3 G, D) z3 M- k* T
#--------------------------------------------------------------------------) w3 U, |2 s- P+ n4 V% T
alias sion_mouse_update_scroll update_scroll
- r( a$ h# D( m
def update_scroll(last_real_x, last_real_y)- x& X/ I: r2 K9 q$ e) f( M
return if $game_map.scrolling
" @ R2 ]( U- M" |9 J& G8 n
KsOfSionNew_Scroll new_update_scroll
. d* B5 s p! A# X% X/ B5 N
sion_mouse_update_scroll(last_real_x, last_real_y)5 C9 z6 k/ m1 A
end
3 i( Z: w) L( D+ G# I2 Y% v' f* p
#--------------------------------------------------------------------------
2 f5 o4 ^# c, _$ k- U
# ● 重置移动路径相关信息
6 `' B3 q( N. v$ Q3 I4 n
#--------------------------------------------------------------------------( Z$ S$ _7 N7 l4 M0 y
def reset_move_path
. t, R4 _& V) g
@mouse_dash = false, Y+ w% p, m: F( x( Q8 ?6 m
@mouse_move_path = []/ q, A! C, F4 G/ d
$mouse_move_sign.transparent = true
0 k* z( c, E% n* M; W
end7 x, D6 s, [5 W* P" C
#--------------------------------------------------------------------------+ ?8 | `) K9 l" X( i3 ^, r
# ● 新的卷动地图方法+ ^7 Z! z6 ?9 A. d7 [9 O7 g, w. O
#--------------------------------------------------------------------------
5 z4 T* H, m+ ]9 f
def new_update_scroll
6 @; Q* Y# Z! x% b
horz_speed = 2 @move_speed KsOfSionMap_Scroll_Spd Graphics.width( T( |; m5 p2 ^3 u
vert_speed = 2 @move_speed KsOfSionMap_Scroll_Spd Graphics.height
! v/ |* v* s9 c' u
ax = $game_map.adjust_x(@real_x); Z% z% @% I5 c- z* _+ f
ay = $game_map.adjust_y(@real_y)
# o8 ?& O. ?! m1 D! W1 b
$game_map.scroll_down (vert_speed (ay - center_y)) if ay center_y
! D7 E/ S! R) q3 R p
$game_map.scroll_left (horz_speed (center_x - ax)) if ax center_x: v! }) V C! T0 R; ?
$game_map.scroll_right(horz_speed (ax - center_x)) if ax center_x
4 X* e; a2 @# E4 G; d+ D
$game_map.scroll_up (vert_speed (center_y - ay)) if ay center_y
& R7 u# s' T" ?, S# _! i8 I8 M* F4 O
end4 E5 b# S6 N; t0 T& O% H* S- t
#--------------------------------------------------------------------------
5 F& i; u. v3 X3 C3 D- _
# ● 消除不能抵达图标
: I4 _1 y4 Q1 m) ^. a+ q
#--------------------------------------------------------------------------
; R$ E# {6 }* {8 y* ^2 ~7 b& b
def clear_unreachable_sign9 J: X0 N+ F5 b# X
return if Mouse.press(0x01)
) `& Z0 F. L: i. Y# [% L5 F. {
if $mouse_move_sign.direction == 4 && Mouse.click_count % 20 == 0, B4 F: _6 a( {1 b2 ]) l; i5 D) I
$mouse_move_sign.transparent = true8 k/ ~) c d* _3 i
$mouse_move_sign.direction = 2
0 q% x) E" m* v9 L$ O( o' a* L: L
end4 K# ~# }7 ^* @. H
end
# b" o: T" {% l# Q" D
#--------------------------------------------------------------------------
9 }0 h+ |* ?) J7 b
# ● 由鼠标移动$ `+ m3 A9 B4 l% u- F
#--------------------------------------------------------------------------2 B6 u. L: O h: [6 M. P( k. z0 v
def move_by_mouse5 Y- h% V: z; E: Y; I% [0 |0 O
unless @mouse_move_path.empty # 移动路线数组不为空则执行移动7 ~: t0 [' f! K- `
dir = @mouse_move_path.shift1 Z0 G1 J! g4 f* s9 @8 I' q
if passable(x, y, dir) && !@mouse_move_path.empty
; E1 u- ?" L9 X; C+ w. a
move_straight(dir)9 n8 m2 f- Y7 `" Q) z% N
elsif @mouse_move_path.empty # 判断是否是最后一步6 t) V+ q$ z! o: i
x2 = $game_map.round_x_with_direction(x, dir)) c3 I3 _5 Q0 }+ K2 V
y2 = $game_map.round_y_with_direction(y, dir)
/ {8 U2 U# _, q" b
move_straight(dir) unless dir.zero
/ e9 V" p+ n& r1 x) S- {
unless x == x2 && y == y2 # 如果移动失败，检查是否启动前方事件、上下载具
+ w0 S4 R6 B7 G' N: k
check_event_trigger_there([0,1,2])+ V$ j k1 b+ X/ P3 F; I
get_on_off_vehicle unless $game_map.setup_starting_event: B8 C H- [/ j% k: D1 I& i
end
3 k) _9 M2 d' Z/ ]) y
$mouse_move_sign.transparent = true if $mouse_move_sign.direction == 2
6 M1 j1 @* O: Z
@mouse_dash = false4 [# Y( S. R0 p* q1 P
elsif @mouse_move_path[0].zero # 目标点无法抵达，调整朝向→目标点
& T. i& V0 Z( x! g! }! e
@mouse_move_path.shift1 y" ~% F9 I4 }0 J3 G7 Z4 J
@direction = dir
+ O2 }( D/ _1 o7 j- P/ @& W# i
@mouse_dash = false, g3 w" o6 k/ p
else
# y1 Q" c# A6 h
draw_move_path
2 s1 a/ X! X9 v O+ v: i0 k0 g) W5 A
end1 `6 r' X! k0 Q
end, `, B* Z x$ T& F. q* n
end/ l. W+ d, h9 ?6 e2 I1 \ Z
#--------------------------------------------------------------------------
w; W# b' C, Y
# ● 地图界面按下鼠标左键的处理
6 P5 g+ d0 H( Y# j* \
#--------------------------------------------------------------------------# B9 [& X. Z5 p5 L9 K( C
def left_button_action
) {) j: B4 a- r1 g- j4 v: t
return if !drawable $game_map.interpreter.running' U* k% n' o: E) \
get_mouse_pos7 j1 x, x3 J- `) P* x% l# y8 [
$mouse_move_sign.moveto(@moveto_x, @moveto_y) # 移动路径点指示图
/ z# Y, N" ?% b2 F1 r! r h
if @shift_event2 `7 }- I% u) d' U/ U4 k
if Mouse.trigger(0x01)* [2 V. K& R1 @' L
@shift_event.jump(@moveto_x - @shift_event.x,
, B" `1 G' }6 @2 c e- j
@moveto_y - @shift_event.y)7 w+ F$ @9 v" p+ u1 Y
@shift_event = nil
( E7 a \& u: C6 P* _! W2 {* ~7 D
end5 h' i% W) j& O
return
+ Y# K `: H# @# k' q5 d
end
B; B* Q3 [0 n( W' r. I% y
if @moveto_x == x && @moveto_y == y # 判断目标点是否与角色重合4 a3 k5 h' P; `* \2 p
return if moving (vehicle && !vehicle.movable)
) g% ~5 d. m! K1 L$ M
check_event_trigger_here([0]) # 判断是否触发重合点事件
- R2 ~7 c# K' f5 B* @( Y
get_on_off_vehicle if !$game_map.setup_starting_event &&
! s# o( G5 a5 w
$game_map.airship.pos(x, y) # 判断是否要上、下飞艇& H* M) u" w/ \* T7 i3 p
return) N; p" q3 p3 W/ o$ V+ o2 M5 R! O
end
1 ], a% k( w: h1 c+ i" h
# 判断是否用鼠标启动事件
. b, n, l' D# _! B4 z2 K; i0 K# w
$game_map.events_xy(@moveto_x, @moveto_y).each do event
1 s0 s# C% a3 R: O" Q
if event.mouse_start- w" L9 t) S* M# I g* X
reset_move_path3 [. `- _7 b- A& L2 `) U& H# I
event.start if Mouse.trigger(0x01)& ?' T# P) u9 e- w# K5 `: X6 R
return
4 M- @! y: G. ^# M- v5 Z
end
' z& o6 k: l5 L: [
end+ U! b5 O( e- E% l1 Y7 h
@mouse_dash = true if Mouse.double_click # 双击冲刺
& G8 S$ U u& W" {
return if Mouse.left_state % 10 != 1 # 按住鼠标左键10帧绘制1次路径9 f6 h; O' P, T
for i in 1..4 # 判断目标点是否为角色周围四点, Z2 b# z6 A& B7 O- H$ \9 @
if x == $game_map.round_x_with_direction(@moveto_x, i 2) &&
( W) H* o7 ]" \( C( h+ u
y == $game_map.round_y_with_direction(@moveto_y, i 2)
& J$ g* [. R4 E. @8 \
$mouse_move_sign.transparent = true2 o& k( I8 R. Z/ w$ b; S
@mouse_move_path = [10 - i 2] if Mouse.trigger(0x01)5 o5 m& j. n! E, z* E
return; end
5 z4 F! b& p3 b2 P
end$ o8 |% K6 v* X- I
draw_move_path
7 @% F5 V3 y- M- A' ?6 s' f0 ~6 o j
end* x5 F8 U$ }. M" p1 x
#--------------------------------------------------------------------------
3 }3 b- |' _4 ~
# ● 取得鼠标处对应地图坐标点# Q1 r% @6 ^9 `* A
#--------------------------------------------------------------------------( N$ Q1 x) y2 k
def get_mouse_pos2 k0 K# k1 c" F" \* r. O6 x( j% _
$game_map.get_mouse_map_xy( K8 M, \7 L6 d/ J4 l1 b9 m! ~
@moveto_x = $game_map.mouse_map_x/ \' _% I$ ^# R. L: R) X
@moveto_y = $game_map.mouse_map_y
" j) h0 R* S# J0 P, W% r
#mouse_x, mouse_y = Mouse.get_mouse_pos% k1 Q3 q1 I. s, t- _" H% P
#@moveto_x = $game_map.round_x(x + (mouse_x -
2 S! w. |0 b! V# `, Y
# ($game_map.adjust_x(x) 32 + 16).to_i + 16) 32)
6 \6 N0 W! w: v1 ?4 Z
#@moveto_y = $game_map.round_y(y + 1 + (mouse_y -
! T% u: j; }, o
# ($game_map.adjust_y(y) 32 + 16).to_i - 16) 32)# S$ I6 X+ s a
end4 ?8 B- I' b( A- Y2 \( E
#--------------------------------------------------------------------------
" E/ W+ N$ x: M y' @# M: u% T' u7 M
# ● 绘制移动路径 @array[move_directions...]
& B$ O+ Q. g* z& t
#--------------------------------------------------------------------------+ C: k6 x0 ^$ w5 E
def draw_move_path* w: L. C- Z8 ^) l6 P
#temp = Time.now
8 K: K" W: I/ J, o( W* {8 x
case @vehicle_type
+ E& P# p5 m3 B
when walk1 X2 U* ?; }# ]4 o
draw_walk_path
2 R7 F' A5 a9 |. r- f4 |
when boat
3 ]/ U3 W) h u
draw_boat_path
# @: ?, Y, n3 T( K; n0 n8 N/ h
when ship) L: Y( B8 v Y" L1 \3 M: r( J
draw_ship_path6 i& [/ w! O# a: V3 T
when airship" P. s' b8 g' Z" R8 ]
draw_air_path- ^# P( c$ q) Z0 d1 S8 y2 ^
end: A. { l x) s- k2 L1 d! A
#p (Time.now.to_f - temp.to_f) # 测试效率. u) u' w- n$ T! `/ `8 G H3 y
end- [, l/ C( n5 @+ b7 r
#--------------------------------------------------------------------------4 d, f- J7 y2 g' c0 `
# ● 判定是否可以绘制移动路径* a' {6 q! b, j
#--------------------------------------------------------------------------: I. z5 l3 `& Y" f7 E
def drawable" r: u, y7 |6 s) E( J
return false if @move_route_forcing @followers.gathering( ]! r$ {2 T6 n: H7 O
return false if @vehicle_getting_on @vehicle_getting_off8 \5 X' o8 ^4 g& t7 u$ i5 S; ^
return false if $game_message.busy $game_message.visible' Y% {% z% G$ D# R
return true' f0 V* l1 Y8 T& g( J. k
end7 ]# |! V' b0 r5 s; u) I
#--------------------------------------------------------------------------
1 k% \( s6 {4 n! N. d% d" j
# ● 绘制walk移动路径 @array[move_directions...]2 }" R Q" |1 |
#--------------------------------------------------------------------------
8 d% `, H; [$ ]+ s8 c
def draw_walk_path9 k# E5 J& b4 |. @! d
# 准备绘制路径表格
7 M2 |* [6 o$ e
sheet = Table.new($game_map.width, $game_map.height)
- u5 Z5 A4 x& B* V( O( Y7 g
reversed_chase_path = []; chase_path = []; D2 d* |8 I2 V) d: E
reversed_chase_point = []; chase_point = []
- c& z ~% K }8 ^' n
new_start_points = [x, y]; new_end_points = [@moveto_x, @moveto_y]
3 I3 N, k- y S8 W$ {, Y0 D
sheet[x, y] = 1; sheet[@moveto_x, @moveto_y] = 2% `8 r1 `9 B; i+ o* X3 @/ X
reach_point = false; n$ M& x* M4 l F) C! K0 U
step = 3: |, M9 ~1 l( z# O/ P/ l7 C
loop do #loop1 开始填充表格
* ]4 c/ H% i* s- z* n
draw_path = false2 D8 C. j! R4 T- Q, K
check_points = new_start_points
' N8 ~0 ]9 ]; p+ A+ \( k
new_start_points = []
1 D! O$ A R) N
loop do #loop2 从起点开始正向填充$ ]. x5 Z2 g" {: Q
point_x = check_points.shift0 V: ?$ ]/ a! i" c6 o' H) L* m) x3 e
break if point_x == nil y: D" D: } m; E6 s6 H9 V
point_y = check_points.shift7 G' h& T' Z& B# ?+ Z6 ~+ x
left_x = $game_map.round_x(point_x - 1)3 \9 O+ b; |' e" j$ n) k! v
right_x = $game_map.round_x(point_x + 1)! H1 O8 b5 w, K2 H
up_y = $game_map.round_y(point_y - 1)8 v. K# x$ S: W$ K
down_y = $game_map.round_y(point_y + 1); x6 Z0 J1 E5 ?* P' }
# 判断路径是否连通 m% \9 v% U {6 J \* o
path_step = step - 1# w) K( @% G; s, S) t/ ]9 m* n
if sheet[left_x, point_y] == path_step &&3 A9 t$ B( S0 m" d( R! @$ V
$game_map.passable(left_x, point_y, 6) &&
3 |9 E* B9 m2 P# _- p: U
$game_map.passable(point_x, point_y, 4)
9 w; F, ]1 R% w$ N" h
chase_path.push(4)
. Q1 d7 ^ N' r# p
chase_point = [left_x, point_y]
& d/ w" Q7 S. }+ o/ X0 f, O
reversed_chase_point = [point_x, point_y]
D3 R, G6 K* Q$ j
reach_point = true; break
% G, L; }. O- `# g0 m0 `
elsif sheet[right_x, point_y] == path_step &&
& f0 ]" n: H K6 W3 y# V K/ r
$game_map.passable(right_x, point_y, 4) && X$ V+ ?! R. T/ s I
$game_map.passable(point_x, point_y, 6)
- d1 k& i6 f% i
chase_path.push(6)9 m9 P, j% U/ `7 g& Z6 y% G
chase_point = [right_x, point_y]
2 M1 c3 }8 G5 C: @0 r! u
reversed_chase_point = [point_x, point_y]; L$ z, o$ }0 X9 Z2 C
reach_point = true; break
/ X/ t, O/ q' c5 e2 {- C
elsif sheet[point_x, up_y] == path_step &&! j+ w, m0 c1 E
$game_map.passable(point_x, up_y, 2) &&# o/ v) [1 T, B8 P+ D
$game_map.passable(point_x, point_y, 8)9 P$ s7 }1 T: Y: H# |8 Y! k7 K
chase_path.push(8)) D: t3 i" q9 A) N
chase_point = [point_x, up_y]
( G4 ~ U/ H* ?8 p7 ~" s
reversed_chase_point = [point_x, point_y]5 u- m9 y$ J. \
reach_point = true; break1 a: |/ D, ~9 X" \
elsif sheet[point_x, down_y] == path_step &&5 k( M. \3 u& w
$game_map.passable(point_x, down_y, 8) &&
7 M* X' f. i/ w, X
$game_map.passable(point_x, point_y, 2)
8 j9 o# |! n0 y: {8 ^
chase_path.push(2)
* K2 K; w# _" n% t7 h
chase_point = [point_x, down_y]+ T. g% f, ? o5 R y
reversed_chase_point = [point_x, point_y]
; s. ?, U8 V6 ^
reach_point = true; break; X6 `0 `% \' D. E- G4 S+ h/ r
end% A3 Z7 l4 q3 C8 {; p7 R3 f% T
# 以需要抵达该点的步数填充路径表格 #
* O3 T& I: Y% l; C. W' H. a
if sheet[left_x, point_y] == 0 &&- _7 x' v, v3 e
$game_map.passable(left_x, point_y, 6) &&; |3 E+ R% k" T# W; u2 c
!collide_with_events(left_x, point_y) &&
5 t/ @( U! X0 s+ I
$game_map.passable(point_x, point_y, 4) &&
6 N' Q7 v8 _. r! E
!collide_with_vehicles(left_x, point_y) #judge_end9 [' T8 L4 Z+ u' Y& H- x0 O( A
sheet[left_x, point_y] = step9 x! t* t( B" q+ [8 p* Q1 [: v9 g
draw_path = true5 I. g" C( [% `9 H+ u( G" w8 N
new_start_points.push(left_x, point_y)
# G% H; I7 w! O3 Q7 r/ E
end5 Y1 [7 X2 z" k4 S; Y
if sheet[right_x, point_y] == 0 &&% j' l* v. o! X# X1 }
$game_map.passable(right_x, point_y, 4) &&) A1 O& Y1 c i; v* U1 ]: ]
!collide_with_events(right_x, point_y) &&( P9 _# y, ` L& K. n
$game_map.passable(point_x, point_y, 6) &&
6 J, G1 X9 R: ^/ d6 N
!collide_with_vehicles(right_x, point_y)#judge_end1 E$ X" E4 h# b! `5 M3 S
sheet[right_x, point_y] = step
8 ~. e& F+ ?# K3 g0 j8 P
draw_path = true5 y5 N1 L1 d) E1 O5 y$ T
new_start_points.push(right_x, point_y)
4 p( b+ _- \ Z$ T
end$ u& [* w# ~. A$ E( g
if sheet[point_x, up_y] == 0 &&
4 z" p4 z6 a( x
$game_map.passable(point_x, up_y, 2) &&
w0 f4 M) R# g+ V
!collide_with_events(point_x, up_y) &&
) X7 ?: |0 a* e- G2 Y
$game_map.passable(point_x, point_y, 8) &&- c7 N4 u; K: b# Q8 G+ o
!collide_with_vehicles(point_x, up_y) #judge_end
P+ T( ^8 E' Z+ i+ p! K
sheet[point_x, up_y] = step
5 K7 Q% l2 G1 ?% Q v0 E4 @
draw_path = true# E* }3 c+ k9 g
new_start_points.push(point_x, up_y)3 M4 A0 K- r* k
end5 c8 [) A6 l& c% Y
if sheet[point_x, down_y] == 0 &&- S4 a8 w) f8 K6 `' g- k
$game_map.passable(point_x, down_y, 8) &&7 K I9 A k/ z; ]- b1 N' I
!collide_with_events(point_x, down_y) &&
6 v7 `% y4 F0 ~9 C1 @) N1 ^8 A
$game_map.passable(point_x, point_y, 2) &&( O, z! i( |' |. L5 K
!collide_with_vehicles(point_x, down_y) #judge_end
( b) ?/ k b. P
sheet[point_x, down_y] = step
/ |7 R! m: o/ K ^
draw_path = true. G( X* @% v1 ?8 x2 z; s
new_start_points.push(point_x, down_y)- ?/ }$ U' l% {0 i% J3 ^
end
& F( S. L3 w, o
end#endOfLoop23 p, X* x3 B. I' B+ H; y
break if !draw_path reach_point& T/ B3 }/ j% Z; A+ {+ e# ]9 S
draw_path = false
L* o8 F; U( ]8 ]' h: g, W7 `
check_points = new_end_points6 |/ P9 V) Z- S$ N
new_end_points = []; b u0 ]$ z& @) A# w; S3 U
step += 1; m# c& `9 g3 j! x2 `1 w
break if step KsOfSionBreak_Steps &&
1 p4 h4 N$ L& W; M p9 X, q4 h; Q
!Input.press(KsOfSionFind_Path_Key)
7 F, X C/ K8 r
loop do #loop3 从终点开始反向填充
# q* `0 N( v& D* c! z
point_x = check_points.shift
/ D, v6 o4 |& y# c+ n8 @
break if point_x == nil
q" r! G, Y% R' v0 g
point_y = check_points.shift
. K3 \2 Y- Z% B
left_x = $game_map.round_x(point_x - 1)
0 H; B% p- z" W7 ]& U
right_x = $game_map.round_x(point_x + 1)* {9 v) M, P2 L! C- L6 \( U' ?: J3 Y
up_y = $game_map.round_y(point_y - 1)1 K( ~7 [" P- ? e
down_y = $game_map.round_y(point_y + 1)6 F2 l2 p9 q# }
# 判断路径是否连通
" _5 q# `0 [/ t0 P7 J
path_step = step - 1% Q# q+ B( L, G+ d* b6 M$ `- }
if sheet[left_x, point_y] == path_step &&3 ^- u" |7 p A- H4 _. R
$game_map.passable(left_x, point_y, 6) &&' @* m; x" F- [1 s' s0 {
$game_map.passable(point_x, point_y, 4)
8 N; \( ?1 `7 `5 r
chase_path.push(6)
3 S- v+ P- T! `5 ]- {4 R, g5 `
chase_point = [point_x, point_y]7 L6 `7 I, U9 n- M l
reversed_chase_point = [left_x, point_y]
$ x: w8 B, |/ t' k& t8 Y$ s
reach_point = true; break
6 G8 U+ P) X: F# G4 _5 ?# [- u
elsif sheet[right_x, point_y] == path_step &&
% [: k; C4 _" J9 ?
$game_map.passable(right_x, point_y, 4) &&8 U' u+ W3 l0 x5 ]
$game_map.passable(point_x, point_y, 6). C1 h) r. Y; O1 h
chase_path.push(4)
' d0 C4 E# w" L- u" S
chase_point = [point_x, point_y]
; Q+ {$ D7 ?. L. h: q
reversed_chase_point = [right_x, point_y]
! T6 a4 X1 ]" Y- z4 n/ K5 A# F
reach_point = true; break
$ I/ [0 Z* e1 C
elsif sheet[point_x, up_y] == path_step &&
9 h. \0 T, @! Q0 K$ M8 w
$game_map.passable(point_x, up_y, 2) &&
* g4 H5 G# Y/ ^' x2 y a; m0 j
$game_map.passable(point_x, point_y, 8)
4 b* m# C% w& u! q& [+ ~
chase_path.push(2). Y9 P. H1 h7 Z% U7 p' X. ?+ j
chase_point = [point_x, point_y]& R, e) L. i3 y0 e* d- O
reversed_chase_point = [point_x, up_y]
* p0 ?6 Q/ q5 G2 u Q; C; Y1 s( k
reach_point = true; break
) k; x/ e q( E9 R$ z2 t h
elsif sheet[point_x, down_y] == path_step &&1 u8 d: }$ H0 `2 w* K; [0 i
$game_map.passable(point_x, down_y, 8) &&$ c G! e6 g% W# T
$game_map.passable(point_x, point_y, 2)
p1 |, Y% x/ K" b
chase_path.push(8)
0 O2 X# Q/ y+ p; h1 g% [, t1 s- {
chase_point = [point_x, point_y]
9 T- Q2 m0 r! o/ R6 o: C6 L! @6 d
reversed_chase_point = [point_x, down_y]
" R9 k3 w: c* o, O
reach_point = true; break! D/ U' }! P0 g; {, s: ~4 w
end# b" a" A( G: G0 b) A# e
# 以需要抵达该点的步数填充路径表格 #
8 K3 d& B6 _# w: p1 f7 {. h" `0 [
if sheet[left_x, point_y] == 0 &&
7 {8 W e! g: l* Y# ]
$game_map.passable(left_x, point_y, 6) &&+ Q+ l9 C/ U, s' b& f) }2 N
!collide_with_events(left_x, point_y) &&
* g# t: g1 n$ X, e s' A7 Y. a
$game_map.passable(point_x, point_y, 4) &&
# v5 Q+ ~# g6 f, i5 I' o
!collide_with_vehicles(left_x, point_y) #judge_end
& G7 l8 \+ E1 f4 _! t# v# x, w
sheet[left_x, point_y] = step |- K7 |) X$ d% R
draw_path = true# E! b0 ^5 G& m/ x& `, d
new_end_points.push(left_x, point_y)6 q8 O4 g) B, P, k5 c B
end
# M3 l9 N* x8 A
if sheet[right_x, point_y] == 0 &&2 P$ g' `: i0 F0 j
$game_map.passable(right_x, point_y, 4) &&
( Z) g% u8 T+ e2 L2 C" b/ p
!collide_with_events(right_x, point_y) &&
! S8 |' S Q7 D
$game_map.passable(point_x, point_y, 6) &&
9 J' y; N/ n9 c8 x: [
!collide_with_vehicles(right_x, point_y)#judge_end- ?) V% S8 B) }) V7 T8 K
sheet[right_x, point_y] = step9 \# H; b0 Z- G) D: v/ m1 ?1 D
draw_path = true c. b1 T: {# K8 V1 a: H+ ?( P0 [
new_end_points.push(right_x, point_y)
, M6 r. @+ O Z" o+ \/ N$ c: K# |
end
) ]4 g. C0 M3 B: ]' A1 Z/ o' S9 S
if sheet[point_x, up_y] == 0 &&
1 k! |( | B$ |+ z! H) T; C
$game_map.passable(point_x, up_y, 2) &&
; Z# ?( v8 W4 O3 N: V* V
!collide_with_events(point_x, up_y) &&1 {2 g& B4 s' j
$game_map.passable(point_x, point_y, 8) &&9 l& p2 s( J+ p0 m# u- U
!collide_with_vehicles(point_x, up_y) #judge_end
/ G$ h7 Z6 \5 V! V/ [+ t2 j
sheet[point_x, up_y] = step O: q2 q& r5 W
draw_path = true
9 s! C" M1 A( m1 r2 d! M$ P
new_end_points.push(point_x, up_y)) n7 `8 W$ o$ U
end
8 i+ y/ M. ~, o! ^% t
if sheet[point_x, down_y] == 0 &&
! I* `4 J# t# d0 x7 z5 C3 K: Z8 _
$game_map.passable(point_x, down_y, 8) &&& p# B( N0 ~6 O5 S. q9 l; X
!collide_with_events(point_x, down_y) &&( Z. k) K1 R" z" U0 | V! f
$game_map.passable(point_x, point_y, 2) &&
, x' t- O6 y+ y4 L2 b
!collide_with_vehicles(point_x, down_y) #judge_end
/ `. m$ g2 D* A
sheet[point_x, down_y] = step7 |1 r+ T5 B& D# N! K
draw_path = true
$ Z. [, S+ ]; r% D
new_end_points.push(point_x, down_y)
9 x/ g& [( I2 _
end% P. n" Y H5 ~& G Z& o
end#endOfLoop3* E: E7 z, i! ^) J5 L* J% q
break if !draw_path reach_point
# S. B& n# I! b6 i, q% k: O
step += 1; `% i4 v9 n {& j. s4 ]4 U2 v6 Q
end #endOfLoop1 路径表格填充完毕" h! a2 g/ s5 h% a: ^6 G, j |
$mouse_move_sign.transparent = false: L( _2 ?: z) N$ p D; O) l
# 判断指定地点能否抵达- I2 v0 `* E M/ R# g5 R
if reach_point
# X: {8 S4 F1 J/ _4 O {' y
$mouse_move_sign.direction = 2! G9 V3 X m) _" n
else' g u* w, [4 y- F
not_reach_point7 w8 s$ `" E* p0 Y# N
return
+ p L0 ]4 [: ^) d) u: x
end
; Y8 {) B. P5 i8 X. C4 ]
# 根据路径表格绘制最短移动路径（反向）
* M4 W! u5 E( D( G" b6 `( z% h
steps = step 2 2 + 1
$ S0 \- W" y, y* v9 F8 Y
loop_times = step 2
% N" J/ H5 m2 G1 p# M$ e
point_x, point_y = reversed_chase_point[0], reversed_chase_point[1], n# A5 c* u5 G$ S& J' b/ _# `
for i in 1..loop_times # forLoop" a- l# \; |0 j3 A$ r
steps -= 2# w& H4 O4 Y' Y3 Y
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs #反过来？蛋疼了……
; D- Q7 t& |4 i; W# R
if sheet[$game_map.round_x(point_x - 1), point_y] == steps &&
- M1 T2 W3 S% @. M2 f8 q
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&* t- x/ V$ C# U7 s% n
$game_map.passable(point_x, point_y, 4) #judge_end
" @4 `" d7 ]$ l! Y/ } ^! j5 r
reversed_chase_path.push(6)
! c# g, E- U) n! x- h% ^1 f
point_x = $game_map.round_x(point_x - 1)
; ]- M+ R0 j- f! Y1 F2 l
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&- w8 |7 S' D; h1 v* E6 d7 N
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&7 t( }* n' I: T; d1 `8 ~
$game_map.passable(point_x, point_y, 6) #judge_end
$ N) I1 k1 W: T9 p# v- v/ T
reversed_chase_path.push(4)
& M, h: [4 h; L/ w
point_x = $game_map.round_x(point_x + 1)
- d3 v4 p5 z7 y5 J
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&
5 C2 m: F$ C) P& Y) [3 Z
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&
m e- p0 e) B$ L Q- _5 Q
$game_map.passable(point_x, point_y, 2) #judge_end
6 S5 v5 n+ v- C0 r( E' r( s
reversed_chase_path.push(8)
. v/ ]4 B7 t$ r0 [7 c0 B' c
point_y = $game_map.round_y(point_y + 1)
# _, \! e+ v7 j# h5 p
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&
, f1 Q9 D7 y, y4 }& H- p/ p
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&; z) `: M5 x# J5 [3 Q& k, z q7 H
$game_map.passable(point_x, point_y, 8) #judge_end
# W7 i- D6 J* r4 ~
reversed_chase_path.push(2)
( [; n7 V( B0 m& E2 } w
point_y = $game_map.round_y(point_y - 1)2 E ?+ M7 o# _$ G
end! {/ m7 I" s5 W
else2 V7 e0 N9 _. l) `) F# X7 w5 _8 G
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&" W2 L2 ]3 z; A) S9 ?& D$ e( |
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&/ b7 r, C9 w8 h8 m! C, ]7 V
$game_map.passable(point_x, point_y, 2) #judge_end+ c1 q$ [' ?4 i& w: r. \8 ~
reversed_chase_path.push(8)1 n* ?. o" e& g( H: N; x
point_y = $game_map.round_y(point_y + 1)+ u- ]1 D4 W0 ~& H$ X" `% O
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps && `- j+ V T7 o" J4 m* `
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&# k- j: y6 h2 C0 b, N% y2 ~* C
$game_map.passable(point_x, point_y, 8) #judge_end
& h1 r. I( z K, z# E/ f$ M
reversed_chase_path.push(2)3 y' B: f5 w' T4 O' d6 }. B( y
point_y = $game_map.round_y(point_y - 1)
, s$ [; d9 M( l2 D( J
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps &&
' \. l6 b g# J( b( G
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&
& C. A- C* t$ C6 E. X! v! J
$game_map.passable(point_x, point_y, 4) #judge_end$ \! O! v0 D8 \9 h
reversed_chase_path.push(6)
6 R! ]' K& w* K% {. e" W
point_x = $game_map.round_x(point_x - 1)- \5 X m7 ~7 V* G
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&
- I* V3 \3 r5 P+ T/ X
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&
$ q8 W' K, ]2 i- r0 ]
$game_map.passable(point_x, point_y, 6) #judge_end* o$ S. D W/ R, k- b8 q, j
reversed_chase_path.push(4)/ u6 b, k" I" T, D* b
point_x = $game_map.round_x(point_x + 1)' b; A6 f; J# X5 ]: s9 g
end7 u! l% O6 k$ k( n
end H. p, B( `2 d$ ^9 h" e
end #endOfForLoop
, m7 T5 F1 P" K2 K9 k6 ?
# 根据路径表格绘制最短移动路径（正向）
0 h6 q( V: c% E7 O- n
steps = step 2 2
- j( W, o0 B+ z% W# p
loop_times = step 2
1 K2 g3 H8 s9 R! k5 D; Z
point_x, point_y = chase_point[0], chase_point[1]
) c* e5 f1 D7 L
for i in 2..loop_times # forLoop
% U, y( j; h R7 {( E& I. G. H
steps -= 2
! H# z* Y( n- g5 I/ Q {
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
' \2 {/ ~' ^! p6 d4 g/ X: |( f
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&
b6 v& Q: k8 a, w& ~* x5 D" d
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&: a3 Q f1 B4 { c
$game_map.passable(point_x, point_y, 2) #judge_end) v; r* \8 r% M
chase_path.push(2)
5 o- L+ k! [+ i- O; r" \) d+ ]
point_y = $game_map.round_y(point_y + 1)
0 \" `1 F& ^; H
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&- ]. P) g: X/ j! N
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&
% i: c; W4 S3 p7 s D" q) p$ e
$game_map.passable(point_x, point_y, 8) #judge_end3 l! n; h8 U3 c) s7 E
chase_path.push(8)/ u6 A3 \' i1 C4 _# w
point_y = $game_map.round_y(point_y - 1)& B+ B. m* g" y1 {% C! g
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps &&+ w0 i& u5 _8 Q( U- q$ \
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&
- H( ^) F4 G, [9 Y; V. l8 j
$game_map.passable(point_x, point_y, 4) #judge_end" O3 H+ n. K# z( u. |
chase_path.push(4) s+ T/ u( y9 m5 A% H2 A
point_x = $game_map.round_x(point_x - 1)
' o0 v! i" t! @6 W9 m' F& {
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&
8 Y5 T- z) q! R
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&1 {( z& P% }4 ?
$game_map.passable(point_x, point_y, 6) #judge_end+ e7 X, Y! ~% {. a, S+ k( N
chase_path.push(6)2 U; w. f7 Q8 ]) i% D0 n
point_x = $game_map.round_x(point_x + 1)
# d5 X% g6 y7 g7 M3 d
end. M4 L( b7 x# b! k* M0 k: b) ?
else( _, k0 f" m5 d+ Q/ e9 q: I
if sheet[$game_map.round_x(point_x - 1), point_y] == steps &&
: q+ q: k. o6 I3 T( D
$game_map.passable($game_map.round_x(point_x - 1), point_y, 6) &&
7 L) W0 ~# S& ^! A7 M$ h
$game_map.passable(point_x, point_y, 4) #judge_end
! Z: F% x, w" h) U4 A7 `
chase_path.push(4) m2 x$ Z% }! a: A1 ]% Y
point_x = $game_map.round_x(point_x - 1)) Y5 e+ j( d1 |: l; X/ q8 L* s) P
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps &&5 o) {% I$ b! P& E) j
$game_map.passable($game_map.round_x(point_x + 1), point_y, 4) &&9 L! s0 y* j' ~: l
$game_map.passable(point_x, point_y, 6) #judge_end9 c& Q, X! V7 s
chase_path.push(6)
1 t( o" {5 D2 B- Q: E; w. t
point_x = $game_map.round_x(point_x + 1)2 ]0 G% `& |" v* `5 } t
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps &&4 Z# k2 o$ ~- I0 w4 p/ `; E' {/ M# u
$game_map.passable(point_x, $game_map.round_y(point_y + 1), 8) &&
& t5 c- B W7 y( L+ R( [" D
$game_map.passable(point_x, point_y, 2) #judge_end
; s, v& F& K5 y; q" R
chase_path.push(2)
) v2 D8 I8 [- A' L0 ]
point_y = $game_map.round_y(point_y + 1)' H; F5 E3 f9 q: I
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps &&
+ h1 n7 o$ `5 l! i4 x
$game_map.passable(point_x, $game_map.round_y(point_y - 1), 2) &&
& K. p) Y, Y3 }% z& h+ ]
$game_map.passable(point_x, point_y, 8) #judge_end
3 W0 Y! C0 Q- v& O( o* t
chase_path.push(8): Y& ^; \5 h, Q* v
point_y = $game_map.round_y(point_y - 1)
& D7 L4 g5 }( Q: ~ M
end
6 Q2 F7 j, D+ g0 |5 @5 D7 y
end
3 L v/ l6 j" x) B+ G
end #endOfForLoop( ?- z( D% H9 a0 F
@mouse_move_path = reversed_chase_path.reverse + chase_path
, C, t9 j0 N# y# D/ ?4 r& R4 S$ }
end#walk% F& O' \( c" [# b3 m: l
#--------------------------------------------------------------------------# a4 u3 }$ P5 [% S$ j+ C
# ● 绘制boat的移动路径 @array[move_directions...]/ G7 S- B( W& n! t) K& s, I- ^
#--------------------------------------------------------------------------
* r4 C1 a/ N) H7 R
def draw_boat_path
6 h" _6 `% o, Y% G& a- ?) ?5 \
# 准备绘制路径表格
" h7 @& m8 }6 ?1 u; l n* S! o+ U! n
sheet = Table.new($game_map.width, $game_map.height)2 @9 T# F- T" I5 E1 F5 c/ f1 h
reversed_chase_path = []; chase_path = []' h p7 G1 ~0 Z& x; \
reversed_chase_point = []; chase_point = []6 ?: g& f1 v g6 A8 ]
new_start_points = [x, y]; new_end_points = [@moveto_x, @moveto_y]
$ n4 j. x0 u8 h$ t7 h4 c
sheet[x, y] = 1; sheet[@moveto_x, @moveto_y] = 2
% a+ Z. c) _2 W3 W2 k
reach_point = false
3 D; ?8 h$ u0 j1 d; I
step = 3
" w; V' g' J/ r# D0 F
loop do #loop1 开始填充表格6 m! W) |4 r- v: u
draw_path = false
h1 d& y( `# C- K
check_points = new_start_points4 F4 M0 S! C7 i. b7 K( c- t
new_start_points = []
$ K* ]3 f( }: D# s$ |# \
loop do #loop2 从起点开始正向填充
( X2 y% c+ y2 N4 i3 X u
point_x = check_points.shift3 l2 B+ _% D3 [5 H1 [5 S
break if point_x == nil. E' z. f4 u4 S% F+ X! V3 ?2 O% I/ a( c
point_y = check_points.shift* X5 ~$ M& {* j w/ X/ D
left_x = $game_map.round_x(point_x - 1)
; I* H7 |6 p9 z& v% p6 \+ F7 [; D
right_x = $game_map.round_x(point_x + 1)
3 i0 f$ Y% J! G
up_y = $game_map.round_y(point_y - 1)( b U7 _, V5 {' P& \, \
down_y = $game_map.round_y(point_y + 1)
0 j6 j y/ b0 T2 N
# 判断路径是否连通
/ _. b4 h$ F' _3 S% g
path_step = step - 1
# B3 U% {! a% x9 R6 \( a
if sheet[left_x, point_y] == path_step% ^! c2 Z, T$ s+ O
chase_path.push(4)
6 n Z7 r& \. a& S w& z! L' O
chase_point = [left_x, point_y]
7 n! B5 f l7 ~6 x
reversed_chase_point = [point_x, point_y]1 a7 R! m" g! ~- f/ c0 P
reach_point = true; break$ b7 y1 I6 z) d3 p9 ]0 u* v
elsif sheet[right_x, point_y] == path_step
4 [: ?3 R- t6 d/ q# O; {
chase_path.push(6)
# ~( p6 T: N# a. e6 y9 w% b
chase_point = [right_x, point_y]
+ f8 V9 n% ?2 {" H6 O, d$ e
reversed_chase_point = [point_x, point_y]7 S. }; c9 Y3 F, L. l) L
reach_point = true; break' ^: L! U9 b, b m, J8 b9 m
elsif sheet[point_x, up_y] == path_step' p! S7 m S0 g" k" i
chase_path.push(8)
8 \+ r9 u8 d. N: x4 a, Q& D# w: b7 J! e
chase_point = [point_x, up_y]0 v9 ?) y' k1 d- q7 T
reversed_chase_point = [point_x, point_y]
6 g" D9 D, R. ]+ V( \
reach_point = true; break! }+ U! F1 a1 \8 l4 x
elsif sheet[point_x, down_y] == path_step
1 p8 d) S, n g
chase_path.push(2)( n% T9 X8 S- m5 S8 s& `
chase_point = [point_x, down_y]5 _: y: Q# d- B9 k
reversed_chase_point = [point_x, point_y]. F3 C3 p1 X8 {4 k2 ]
reach_point = true; break% m) [! ^# ]1 l9 Q
end
" @+ I" f+ c$ B& C& V1 _ Z
# 以需要抵达该点的步数填充路径表格 #
- x' Z4 p* I" U* Y
if sheet[left_x, point_y] == 0 &&
3 p# M' a3 P& J3 U L( v
$game_map.boat_passable(left_x, point_y) &&( a/ r& z3 a1 \3 T3 n' e
!collide_with_events(left_x, point_y) &&
8 G; j* i% B+ F) g" N
!collide_with_vehicles(left_x, point_y) #judge_end
, B6 z* {# I* C9 x
sheet[left_x, point_y] = step
' R) w( ]6 ?& s7 G+ j
draw_path = true
8 l- d" P8 K2 Z: v( m( H, ?; t
new_start_points.push(left_x, point_y)# R$ S" B, Q# d! f" k
end
0 `* ~ W. a, t% g( u- l
if sheet[right_x, point_y] == 0 &&
) v v' ]3 x2 E. I" M
$game_map.boat_passable(right_x, point_y) &&
3 k( v+ u! [4 r4 |: L$ P
!collide_with_events(right_x, point_y) &&/ I8 Z0 P% f* G- t# C) E, y
!collide_with_vehicles(right_x, point_y) #judge_end4 Q2 ]' G( k0 @: Q
sheet[right_x, point_y] = step
4 ~5 ~% o( d3 R# C3 T0 P
draw_path = true. \& N8 ?/ ~, u$ n
new_start_points.push(right_x, point_y)" g, f# P* w! ], v) @; |3 r
end
- p8 n( g+ n @- M. |
if sheet[point_x, up_y] == 0 &&# r' ~$ C8 F" w0 g
$game_map.boat_passable(point_x, up_y) &&
$ @ v. [# _( J, d9 O6 S! \3 Z+ X
!collide_with_events(point_x, up_y) &&1 l9 E. o( ]- x. a" \8 V
!collide_with_vehicles(point_x, up_y) #judge_end
8 b @, [/ [0 o& u
sheet[point_x, up_y] = step
) D. f% `) t- i; s8 s8 f0 P
draw_path = true4 O. I o2 D6 Z- |& w0 X
new_start_points.push(point_x, up_y)" W9 @) b6 `; s7 o; o
end! E1 x8 a1 o8 G; @3 [$ I3 ^- H3 B
if sheet[point_x, down_y] == 0 &&
% P- E4 ^2 {4 X
$game_map.boat_passable(point_x, down_y) &&# y/ \) G. _2 g- P6 t) v% A0 m1 U
!collide_with_events(point_x, down_y) &&- e" h( q# J7 A! g
!collide_with_vehicles(point_x, down_y) #judge_end
8 c, b. M- d( D: E( Z
sheet[point_x, down_y] = step
4 d& c8 V! A- k/ p7 d
draw_path = true; r# { y5 C, B+ |3 p( [
new_start_points.push(point_x, down_y)
end8 ?, t) k7 P+ K. y
end#endOfLoop2
+ x, r/ }0 E& [
break if !draw_path reach_point
5 C2 z1 ?* n8 v4 [3 u2 }" g* _
draw_path = false
0 t( K. K: N$ f$ f% X$ l r `
check_points = new_end_points
/ z+ b3 Q7 X8 [" h
new_end_points = []
7 Y' `; |8 Q& T4 K# C
step += 1
0 K8 E5 U; P+ e
break if step KsOfSionBreak_Steps &&
+ [ e/ u3 z4 d* R* {3 D
!Input.press(KsOfSionFind_Path_Key)
, R5 m' x5 c! o- x
loop do #loop3 从终点开始反向填充
4 r. g8 H H8 m( X8 m; o
point_x = check_points.shift
s) P( ?& y" ^7 b1 @( w6 C
break if point_x == nil
) y# l: I$ |+ r u4 e3 V) v1 |2 x
point_y = check_points.shift
! t0 K6 O* l; h1 h
left_x = $game_map.round_x(point_x - 1): W- }6 {* y5 \3 `- R& Y8 U1 I$ k
right_x = $game_map.round_x(point_x + 1)+ [9 \' {4 m: D3 Y" A& e
up_y = $game_map.round_y(point_y - 1)
! Z1 g4 C* C4 w. b0 R- j
down_y = $game_map.round_y(point_y + 1)
2 X4 o' n- U$ k# F' n
# 判断路径是否连通" l4 V: I g5 E! F$ P
path_step = step - 1# E! }! K6 [ j6 e& i1 @
if sheet[left_x, point_y] == path_step
$ j/ X0 i" G0 M- i* ?0 p
chase_path.push(6)0 ~( o2 k7 O( G- O/ T! |, s" H
chase_point = [point_x, point_y]
# q8 l3 G4 i& ]; a
reversed_chase_point = [left_x, point_y]
( b0 A, Z2 x6 c
reach_point = true; break
' G {! Q5 { s: O
elsif sheet[right_x, point_y] == path_step/ J8 R: j: Q Y" x) |* r4 ?4 b
chase_path.push(4)7 A, D8 O" p/ g6 C$ L. u
chase_point = [point_x, point_y]
1 K0 E" Q; J1 Y8 H8 `+ ?
reversed_chase_point = [right_x, point_y]
9 ?& [7 D6 n2 b, ^# ^- Y+ C
reach_point = true; break
5 N# H3 o! S% i2 u$ u3 h; r
elsif sheet[point_x, up_y] == path_step
7 h8 S o6 d, Q: r! t1 v' B
chase_path.push(2)
. Q$ k4 \3 p) D+ R0 r- y
chase_point = [point_x, point_y]* p! X; k( P/ r% x' b: ]# _
reversed_chase_point = [point_x, up_y]) V2 V) [. O- N9 S5 r# B9 y9 g
reach_point = true; break
' r: Y( j5 F( B6 p v$ ]
elsif sheet[point_x, down_y] == path_step
$ r; N1 [% w, Q) n
chase_path.push(8)
; A! T- `6 d5 m( J& ^/ { l
chase_point = [point_x, point_y] b: u9 w- Z1 [) n6 D2 D5 M% E
reversed_chase_point = [point_x, down_y]
+ `! `" s2 }9 w! n% L/ v
reach_point = true; break
2 w9 V5 Z* Z/ r8 R& [, Y6 O( G$ m
end9 Y7 o! B" L' {/ V6 p% l/ S
# 以需要抵达该点的步数填充路径表格 #
3 [- H; V" G1 ^# w# G
if sheet[left_x, point_y] == 0 &&% k0 |( `* M5 J* o& }7 M) q7 o
$game_map.boat_passable(left_x, point_y) &&
. J1 i0 E: S! m5 g
!collide_with_events(left_x, point_y) &&
' i$ O6 t2 A" V6 g2 W) Y# m
!collide_with_vehicles(left_x, point_y) #judge_end; K! o7 k& y0 a0 }; x4 a- f6 ]( l
sheet[left_x, point_y] = step
; Z# J% n4 v! l" F) p4 o
draw_path = true
0 V( K9 w1 ?4 c) ]8 I, B
new_end_points.push(left_x, point_y)8 G# G) T# p V6 R6 L5 J+ r/ S% G
end
- k- S0 J5 ?9 K, L( F
if sheet[right_x, point_y] == 0 &&% l& r1 F8 n* a$ ?& p8 @3 q7 h( x: l
$game_map.boat_passable(right_x, point_y) &&/ s4 | F- C% g
!collide_with_events(right_x, point_y) &&
1 R" s c& Z! t7 l4 O
!collide_with_vehicles(right_x, point_y) #judge_end
+ N* Q0 L# X5 \2 p% j% c" u
sheet[right_x, point_y] = step0 z& q2 D" J0 P8 h9 a) F S
draw_path = true
2 m/ H' A: G# P/ [
new_end_points.push(right_x, point_y)
& P8 }1 L2 B# n% s8 |
end* `( q$ T$ p( o5 y# s. i% B8 R
if sheet[point_x, up_y] == 0 &&) V S9 ]$ h7 {' u4 [
$game_map.boat_passable(point_x, up_y) &&, t- D" l4 d: r! ?( t
!collide_with_events(point_x, up_y) &&
1 ^. c) \ M1 o) a v) N, S
!collide_with_vehicles(point_x, up_y) #judge_end0 p1 G. x& _. f2 W' _
sheet[point_x, up_y] = step
' y6 j2 j! w% m; @& Z
draw_path = true; S% B$ D% N2 B; u
new_end_points.push(point_x, up_y)# i8 P; a% ?, d" C6 A+ z( w6 T
end+ ]; k- \4 p' ]
if sheet[point_x, down_y] == 0 &&: K2 y! N! h' d/ B
$game_map.boat_passable(point_x, down_y) &&( G& G( D' v2 S# s
!collide_with_events(point_x, down_y) &&
* Y7 r: V8 q' x4 \
!collide_with_vehicles(point_x, down_y) #judge_end4 a# V5 h( E Z- s' U! n: d" j9 q
sheet[point_x, down_y] = step: g8 F" e& F; P" t
draw_path = true. z" A! ~2 [) J/ T k* F
new_end_points.push(point_x, down_y)
* h0 w: F5 L7 E: u x: `) d1 x1 \
end
j1 s, s+ l6 {/ A
end#endOfLoop3$ M# U+ Q* x0 A! N5 F' l
break if !draw_path reach_point
% H0 f! r* ?5 S6 Q8 R5 M
step += 1
3 H1 K0 Y# g* S( A( L
end #endOfLoop1 路径表格填充完毕- d! v# P- ]! A
$mouse_move_sign.transparent = false' l# u2 e( A3 ~) {9 S1 t
# 判断指定地点能否抵达
6 l A |* |8 D/ S
if reach_point5 I+ n' x( O- V" x: t5 }4 P
$mouse_move_sign.direction = 2
! u) F$ K- u' p( s" r. e: u
else4 y* L, b4 Q9 L) n% R
not_reach_point
) J0 S# e( E* y X
return* _) j V/ k9 S' |5 g( g
end' j, S# `1 J3 r3 k D2 k
# 根据路径表格绘制最短移动路径（正向）
6 t; y1 c9 p8 U. w5 |# L6 l
steps = step 2 2
5 O1 Y& V: M I8 W4 W5 z- w' }
loop_times = step 27 a6 V4 Q* Z" ^- O
point_x, point_y = chase_point[0], chase_point[1]: n& v# y% p* E9 V: z6 u
for i in 2..loop_times # forLoop
0 [2 A8 a) Y' d3 k& B) n- E5 Y6 _
steps -= 2
7 z& g9 p5 n! Y! C# ]( p- V6 e$ d
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
2 D/ ]( `: }& R) L1 _# [
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps3 \6 E9 x. f4 d I e5 o1 J
chase_path.push(2)
' H R8 e- ]* K) z9 }5 b. ?
point_y = $game_map.round_y(point_y + 1)
( M& y; B; h3 m; R
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
, {% u2 [. P/ e" C g; b
chase_path.push(8)
5 d9 T9 ?/ K& l& V* l7 w T
point_y = $game_map.round_y(point_y - 1)! _3 Q- N6 ~% A0 O/ W2 n. L6 j" Q
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps) ^: H1 D4 e% H3 z
chase_path.push(4)! z* X3 G$ h$ H& U* n& F" h/ q
point_x = $game_map.round_x(point_x - 1)
" @) E; y+ n; a2 T# W
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps, L' h, K' c9 b& {! U% c- @5 Y! [
chase_path.push(6)" U+ h J8 r: j; ^+ g4 k" |
point_x = $game_map.round_x(point_x + 1): m! D2 Q! o. m
end8 U4 P, d6 X! k2 r
else
, L! Z+ v$ e7 [0 `/ {
if sheet[$game_map.round_x(point_x - 1), point_y] == steps
: ~! {$ j |9 f* L0 R9 m
chase_path.push(4); h8 C4 t+ S. E/ p4 z
point_x = $game_map.round_x(point_x - 1)
+ R' ]1 W e/ Q, P1 X9 Y4 d; e
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
8 _ J! m* p% C! m7 x
chase_path.push(6)
5 d0 G, |+ h/ o/ F" s$ c
point_x = $game_map.round_x(point_x + 1)
# S) @# v$ A+ |. m& J( S. A
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps
. g2 ?% S. M. `2 e
chase_path.push(2)
! ~/ ?% k5 n2 j$ |3 S
point_y = $game_map.round_y(point_y + 1): @, Z7 I7 _, d6 L
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps6 C) Q0 G* q1 ]' E( n* H
chase_path.push(8)
7 l$ `5 ]* T8 `# x
point_y = $game_map.round_y(point_y - 1): }, x! F. _& J6 D6 E: a
end
8 M/ {( k2 }/ q, U; g% e) v
end
3 y% D+ ?, }' j8 E6 Y3 x* `
end #endOfForLoop" m5 W, ^* U# p' B+ k# R7 l) F, d
# 如果指定点无法抵达或者登陆
. R% }( U6 C3 L
return not_reach_point unless landable(@moveto_x, @moveto_y, chase_path)
6 T% F. ~: ^4 k. ~" {, B
# 根据路径表格绘制最短移动路径（反向）( C$ V$ A2 `3 f r* @ S8 n) C- c
steps = step 2 2 + 12 N9 _9 o8 m: H' |2 ~
loop_times = step 2, Z. `' V7 |1 l3 g- I3 d, T
point_x, point_y = reversed_chase_point[0], reversed_chase_point[1]8 D$ \1 W; K N
for i in 1..loop_times # forLoop
, v/ l& ]9 S6 i' z/ K
steps -= 20 m) d7 `# ^: P1 H0 ^1 m
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
t/ o5 Z3 o; B, x/ I6 l6 H
if sheet[$game_map.round_x(point_x - 1), point_y] == steps
6 ]/ s) Q- {' ^
reversed_chase_path.push(6)
% x5 Z/ Q6 s9 B# F
point_x = $game_map.round_x(point_x - 1)% K j9 ]2 l- N5 v# t
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps' x2 _8 R2 b/ |
reversed_chase_path.push(4): w; M* w9 g4 P4 Y* Y! z
point_x = $game_map.round_x(point_x + 1)
7 E1 @1 d; } U0 a
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps
/ m8 }) L* |2 g) T
reversed_chase_path.push(8)3 ^! T5 u$ E: @9 C1 W
point_y = $game_map.round_y(point_y + 1). R/ G5 I5 t4 v2 m |6 s. j1 j7 }3 ^: ?
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
7 S7 l# z. e/ s% Z: F2 b
reversed_chase_path.push(2)
}2 J, P5 v, b; k- @* ^
point_y = $game_map.round_y(point_y - 1)
9 e( _% B% A* i, @' o: T
end
& e: @ s. U+ ]" q) H% l
else- R- m% O! v0 R( D$ P4 ~1 F
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps. Q% z3 U* ~" i. ^
reversed_chase_path.push(8): r- B& ]. L& K* `: g: \
point_y = $game_map.round_y(point_y + 1)1 F& p2 E: `# c! O/ d( t( Z
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps0 g( ?% L/ n6 L( z( x. }( U
reversed_chase_path.push(2)
9 e/ ?) O! g5 Y* U i
point_y = $game_map.round_y(point_y - 1)
/ a5 @6 ^- d: L! @
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps
# c/ h$ v# l4 E+ z: I: S
reversed_chase_path.push(6)
! w0 U% Y3 ?2 m6 Q) `
point_x = $game_map.round_x(point_x - 1), L% _/ p& g5 E
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps, r5 d3 @6 h: C' p x3 u8 ]
reversed_chase_path.push(4)8 [" }9 A; e R6 q- o& C" R
point_x = $game_map.round_x(point_x + 1)" Q4 E6 [! A, f9 d- t! Q- l" H
end2 q2 E' Z- m# h1 s+ i
end
1 y* Z# x, ]9 t! n2 [
end #endOfForLoop
" s8 |/ u" ?" n1 ^9 `3 h( s A
@mouse_move_path = reversed_chase_path.reverse + chase_path8 }3 L. r1 z% \8 m8 K: d
end#boat
/ H4 g3 S3 }( p9 h" E3 z
#--------------------------------------------------------------------------
3 i2 V# T& b& l" e
# ● 绘制ship的移动路径 @array[move_directions...]
& o, E6 A( e- V u
#--------------------------------------------------------------------------, k) C0 z8 |8 h# v2 C3 A3 Q+ I4 ], b; t
def draw_ship_path% z" |% q0 |5 K$ O/ c5 L B
# 准备绘制路径表格
' z9 K. s! w1 `8 P
sheet = Table.new($game_map.width, $game_map.height); F9 w8 e. }2 z8 H ]( F) ^
reversed_chase_path = []; chase_path = []" x- F# G8 w2 n- P
reversed_chase_point = []; chase_point = []
: o: b: \; R6 j9 \& c2 |6 r6 E/ W! g
new_start_points = [x, y]; new_end_points = [@moveto_x, @moveto_y]
* q' E" Q2 u) U, x
sheet[x, y] = 1; sheet[@moveto_x, @moveto_y] = 2
0 ^/ \! x" c$ \8 S' S# M5 N* W
reach_point = false
& P1 @; P! D' y+ K; J
step = 3
( v$ ^: w) k$ a. z1 O3 C6 _5 X
loop do #loop1 开始填充表格
/ g& @* \) J+ [& R; q) Q+ o
draw_path = false
, ~5 `! E9 Q0 n( x6 @8 l
check_points = new_start_points) ?0 K. ^! d' P5 T3 c
new_start_points = []
6 R/ K' {/ q0 C( y! Z- E
loop do #loop2 从起点开始正向填充8 J0 w/ w% P" v
point_x = check_points.shift. c. ]4 [' x* k( c2 V% v8 ?) |
break if point_x == nil: x' o: Q5 b/ \( F# |) r
point_y = check_points.shift4 X5 k. k! T: ]0 K9 v
left_x = $game_map.round_x(point_x - 1)* h% h$ G. G7 Z$ p( h% x" z
right_x = $game_map.round_x(point_x + 1)
# a! D+ [& |6 @& G( s
up_y = $game_map.round_y(point_y - 1)
% C8 i. h4 A) M9 r0 }
down_y = $game_map.round_y(point_y + 1)
& g: T! |# e9 B3 Q0 n
# 判断路径是否连通
* ~7 r7 X% c1 I8 [4 b
path_step = step - 1" p1 \% g* s/ \" y6 H) e/ y8 n! J' f
if sheet[left_x, point_y] == path_step. \) K2 }7 Y* {6 A5 Z3 _/ Q" t( S8 ^( a# S
chase_path.push(4)9 w* k! U; v$ M! n! L0 N! V
chase_point = [left_x, point_y], X, v0 O$ ?$ m% u& p$ c4 ~0 _; x
reversed_chase_point = [point_x, point_y]
* ^; X- R9 H; L8 u/ Q2 o
reach_point = true; break" j& u+ O7 ?% p$ u4 T* l R6 A; G8 O
elsif sheet[right_x, point_y] == path_step
/ e7 Z5 d! Z' D5 M: t- Y- u, w+ w
chase_path.push(6)6 M, R" L. [; ^7 H; Y5 w. N% R2 D
chase_point = [right_x, point_y], ?* T$ e- Y. ], z- {" O2 x1 E
reversed_chase_point = [point_x, point_y]" S x* q4 M4 A' c
reach_point = true; break
8 H2 _6 s0 ~, D5 z# B" ]' P
elsif sheet[point_x, up_y] == path_step, _& Z( H) e+ D: x4 N) U$ s" n
chase_path.push(8)6 b0 O) Y/ Q% F8 z6 a
chase_point = [point_x, up_y]- W' x9 l& V3 j1 L
reversed_chase_point = [point_x, point_y]3 I; N/ u* f& S9 T- ^/ v
reach_point = true; break$ N1 [& W' f' o5 A( }; K$ \
elsif sheet[point_x, down_y] == path_step
( [. p2 @# D7 ?/ [8 {0 \
chase_path.push(2)
0 x* v5 I* V% `$ J: [0 ?. }& ]
chase_point = [point_x, down_y]" g" H3 `2 n0 f! ]) v% E9 Z- d6 D
reversed_chase_point = [point_x, point_y]
3 e+ l% Z' Q! P3 r- V/ T: l
reach_point = true; break
/ ~1 V! g1 c4 a1 ]- p& Q- }/ g' O
end, ^; k. K2 l5 m
# 以需要抵达该点的步数填充路径表格 #9 h9 ^6 T* ~( E P1 Q; d
if sheet[left_x, point_y] == 0 &&
' _. {0 R' l8 j: X* q3 y3 R8 @
$game_map.ship_passable(left_x, point_y) &&0 A1 ~0 o C8 O$ J
!collide_with_events(left_x, point_y) &&
. J* ^4 R! {9 i" ~* f3 g
!collide_with_vehicles(left_x, point_y) #judge_end; |" y: |3 v+ y9 H8 `6 Q$ p/ b
sheet[left_x, point_y] = step
& k( q8 W' h% m: l
draw_path = true$ X T4 b* s3 }0 m8 Q
new_start_points.push(left_x, point_y)9 K( w& S. Z7 n1 n
end
) A B7 z* `. a. {* U( `
if sheet[right_x, point_y] == 0 &&
# e) j4 k0 `$ V, I% B
$game_map.ship_passable(right_x, point_y) &&! R" {; g3 k w% W' f' q6 u
!collide_with_events(right_x, point_y) &&
2 Y! ^! A8 Q# O; [
!collide_with_vehicles(right_x, point_y) #judge_end$ f8 P' S5 R4 a7 q/ Z* z
sheet[right_x, point_y] = step/ P7 k$ Y$ t) `6 p
draw_path = true2 q9 W- Y; G! q: M
new_start_points.push(right_x, point_y)/ u3 c0 r; t6 L2 p/ ^
end3 A$ T1 ]7 C8 c7 R0 n0 f8 _
if sheet[point_x, up_y] == 0 &&3 y2 p# ^( S) Z4 H
$game_map.ship_passable(point_x, up_y) &&' N: `5 M% H% s1 E5 I5 Q1 e1 r
!collide_with_events(point_x, up_y) &&* l3 i% T: [! J0 O( m
!collide_with_vehicles(point_x, up_y) #judge_end
7 v0 _3 s% P- z2 @" E" [
sheet[point_x, up_y] = step
3 `! [0 q: J- H0 F
draw_path = true
B# d x' @+ N6 c
new_start_points.push(point_x, up_y)
5 L0 N1 X' N/ m7 O8 n, G7 x
end1 X. M1 Q$ w- L; f" s
if sheet[point_x, down_y] == 0 &&
+ _6 z5 m0 d% E( _/ M, W. |' p
$game_map.ship_passable(point_x, down_y) &&
8 N! Q% X1 K: i5 e
!collide_with_events(point_x, down_y) &&
5 U- M% ?5 E8 N: ]' I! |
!collide_with_vehicles(point_x, down_y) #judge_end
9 Q% Z/ l' o2 n4 U8 H3 T5 O! N
sheet[point_x, down_y] = step
7 l2 s* G; \$ j4 @6 Q" o
draw_path = true; K* r, t* d% q/ F/ m' @( ]# g1 n
new_start_points.push(point_x, down_y)# t* H/ Y2 Y* K' p" ]
end5 N: w2 i! c+ V% a% q
end#endOfLoop2
6 X8 ?) o7 ]6 J* a
break if !draw_path reach_point3 M8 W( y7 x$ ]/ [: K0 {: ]3 g
draw_path = false* q- P0 Q" i3 x& J6 P/ b$ h5 q
check_points = new_end_points
new_end_points = []$ x4 Q0 N* S2 C" H; s9 q; O. h5 M
step += 1/ {: C% v+ q5 r" N! v
break if step KsOfSionBreak_Steps &&6 n; F d v, r
!Input.press(KsOfSionFind_Path_Key)
' E! R" w; d0 E; l$ E" U ^
loop do #loop3 从终点开始反向填充8 s$ Y1 d- M N- s
point_x = check_points.shift+ ^$ `* ~4 v: K3 q
break if point_x == nil' I, `, r/ @- D! e2 P& O1 r
point_y = check_points.shift
% E }4 w' p8 u% t+ D
left_x = $game_map.round_x(point_x - 1)
L* Y. v$ n" X* z" p8 F
right_x = $game_map.round_x(point_x + 1)
0 f) h9 ]; \/ [
up_y = $game_map.round_y(point_y - 1)
5 N7 M1 u5 [6 _( a/ ]' F3 }0 `
down_y = $game_map.round_y(point_y + 1)
: N0 }6 \8 n" _ Y0 [
# 判断路径是否连通
* J; n% K; L4 N+ J0 w. v
path_step = step - 1- U/ { R6 c* c' T, Z D1 I
if sheet[left_x, point_y] == path_step
7 R- x8 D, H7 h% R
chase_path.push(6)
) e# V7 K- K. R9 i- Y
chase_point = [point_x, point_y]
4 ^4 [7 V Z# v' C5 P6 g
reversed_chase_point = [left_x, point_y]4 l! `; m0 P' p+ m# \6 X/ ?
reach_point = true; break" r% J( ?' y% q b: Q; Y
elsif sheet[right_x, point_y] == path_step
# p6 N: [4 q8 [& s3 k h0 ~7 F5 P8 I
chase_path.push(4)
: S% Q! _* U; j/ x1 N* Z! b
chase_point = [point_x, point_y]
+ E9 z# ~; P( N4 c+ \, D: n1 p
reversed_chase_point = [right_x, point_y]
) ^/ r: d" b6 r6 c! s8 o4 ?
reach_point = true; break
. n/ }* B" C- w6 x
elsif sheet[point_x, up_y] == path_step* H& r: U# ~0 U \( ^; Q' @
chase_path.push(2)
/ V( r9 t: }$ P! ^
chase_point = [point_x, point_y]
) l; j0 w; |1 f; I( @
reversed_chase_point = [point_x, up_y]; W9 b+ U# q5 w
reach_point = true; break
5 u1 y$ H3 P4 y: x, H& Q
elsif sheet[point_x, down_y] == path_step( U) x$ k. i# c( k+ D
chase_path.push(8)0 O% ]/ m0 K5 q2 D6 J
chase_point = [point_x, point_y]
, ^. w( A, E* t, f% o0 r8 {& i O
reversed_chase_point = [point_x, down_y]4 ]* d! [2 \6 K' X9 Z- `
reach_point = true; break
2 P* I1 b0 q, ^" A$ E5 q
end2 |% e) `; J! w: e# v
# 以需要抵达该点的步数填充路径表格 #. b/ l+ S: W! }+ y/ `# k0 k
if sheet[left_x, point_y] == 0 &&& V& a. S. u. g; u
$game_map.ship_passable(left_x, point_y) &&
. e8 H# B. W* {7 R7 ]
!collide_with_events(left_x, point_y) &&6 C' K5 G8 d6 [( D2 r
!collide_with_vehicles(left_x, point_y) #judge_end! d) G5 _9 M! o% s5 t) [7 S
sheet[left_x, point_y] = step
4 ^3 B$ ]/ t8 U4 \$ ~
draw_path = true3 k" e% C* b4 U7 J/ E6 ~
new_end_points.push(left_x, point_y)
5 |+ H' a, E6 T Z0 Z1 g: A l
end& h) ]% w2 h2 T4 Z
if sheet[right_x, point_y] == 0 &&* j0 h( }8 t. p, [: X* z
$game_map.ship_passable(right_x, point_y) &&( T, y' B9 e7 ?' H1 q% j& l! S
!collide_with_events(right_x, point_y) &&
: y- Q5 n+ }5 A( X
!collide_with_vehicles(right_x, point_y) #judge_end9 R% K* @4 V# T: L8 i) @
sheet[right_x, point_y] = step1 h& N* e6 |6 ?# K
draw_path = true- H. O' N7 x# s) A4 T$ n
new_end_points.push(right_x, point_y)
2 N+ q, }- h# M! x$ w- N
end9 h5 `$ k, B$ M' u1 h
if sheet[point_x, up_y] == 0 &&# ^! G! ?% P9 z! H6 ^
$game_map.ship_passable(point_x, up_y) &&
6 C( g( }5 y/ u/ c0 _
!collide_with_events(point_x, up_y) &&+ L' |3 ~9 X; G: N: B" p( V* m
!collide_with_vehicles(point_x, up_y) #judge_end1 V' q0 }! D5 B! U8 o9 L; c+ V$ P& p
sheet[point_x, up_y] = step! f! H# d- n3 n2 M) {5 g
draw_path = true3 d$ N9 K: ^5 v4 g0 W, H- Y
new_end_points.push(point_x, up_y)
" U' }* Q1 ]+ a" R S: D
end) K/ W5 n' ^/ v
if sheet[point_x, down_y] == 0 &&# \2 j. z$ i; ]
$game_map.ship_passable(point_x, down_y) &&
- ^' b% _/ V* o/ M" b1 T
!collide_with_events(point_x, down_y) &&
6 Q! |. }/ m: \$ _( ?
!collide_with_vehicles(point_x, down_y) #judge_end
, Q1 F+ N. I* r1 e- B
sheet[point_x, down_y] = step
: m% q- Y" V/ K
draw_path = true
' t7 a/ o# P4 U; a
new_end_points.push(point_x, down_y)
$ b# x1 i4 Q% O* I: [. W3 Q4 m4 p
end
! P0 a' M% C9 T
end#endOfLoop30 {/ t! \" d8 d& ]2 ~6 T2 U
break if !draw_path reach_point* p! [9 v4 d5 i4 p
step += 12 A) W! h, R& T7 n* X
end #endOfLoop1 路径表格填充完毕& T2 ~' u- F* I% D
$mouse_move_sign.transparent = false
2 p3 A6 c3 V9 X; |
# 判断指定地点能否抵达
: T) {+ x: q0 C7 k+ j
if reach_point
, ^+ |+ |, H6 r9 e
$mouse_move_sign.direction = 2
9 P& o+ L& x8 |* R t1 _# x# T
else! \4 A, S) {1 J/ ^# f: C: \4 ^
not_reach_point
' w: [3 c. _! e" x# D2 _
return: d$ T# W9 d+ G) m
end6 K) Q5 p4 C$ k
# 根据路径表格绘制最短移动路径（正向）( Q \ W p4 ]; j
steps = step 2 23 ?& u l4 @# @) E
loop_times = step 20 W1 c. C {6 k1 k$ B G" J! j3 N+ G6 Z
point_x, point_y = chase_point[0], chase_point[1]. X/ [+ W* P$ Z0 V
for i in 2..loop_times # forLoop5 ` S' R2 D/ B1 E# A
steps -= 2
1 C& }8 J3 B! I$ I2 S
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
, T$ k: D; O9 f4 g, w- j! V! E
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps
3 Y! I! T ?6 R9 B2 C& G" }
chase_path.push(2)
$ [- G+ n5 W: e! M. g3 x$ w! h7 p
point_y = $game_map.round_y(point_y + 1)
& `! s+ P- y, T
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps
6 o: K+ v0 @* ? ^. {. ?
chase_path.push(8)
0 U- |1 J9 c5 R' K2 n% w
point_y = $game_map.round_y(point_y - 1)5 E7 T" g8 z# l/ p6 g/ P, o5 G; \
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps+ W$ R7 H8 v A& u6 w
chase_path.push(4); t9 u7 Q& H6 u+ c
point_x = $game_map.round_x(point_x - 1)! q+ J7 [ k2 q" p0 n- [( [+ T
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps& k0 i5 K# I0 Z7 e& I; F& m
chase_path.push(6)
: I9 |, ~8 Z% [# M
point_x = $game_map.round_x(point_x + 1)
' ^* a$ @& V# m: C
end+ N2 V( G+ [! p# T: I
else
- S% E S4 X$ h, H
if sheet[$game_map.round_x(point_x - 1), point_y] == steps
+ l" Y8 ^! h0 f; @" U
chase_path.push(4)
- U% X# U4 J r+ j/ R
point_x = $game_map.round_x(point_x - 1)
9 U9 G$ k3 |/ C; U
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps1 I5 j% a$ {6 N. ^; K
chase_path.push(6)
C, V. g# K' f
point_x = $game_map.round_x(point_x + 1)- |; n& M- M9 e. U
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps7 U% t! I0 @( Z8 A* G/ O
chase_path.push(2)/ Z1 k) B8 `7 x- x% }' e |, P
point_y = $game_map.round_y(point_y + 1)
! f: _! b6 Z( `$ j2 O% Z
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps6 I0 Y' f8 }5 R0 w+ l+ a
chase_path.push(8)2 q3 ~. g& M! R: l# M% R& J& i
point_y = $game_map.round_y(point_y - 1)+ m! Y2 |% F* ?8 g; _5 d4 ^
end! x1 x( v" c+ |$ C7 `/ u
end* Y5 f1 o4 S* ?4 D/ l! G' K
end #endOfForLoop3 |! P, F' ?' N/ Q/ E
# 如果指定点无法抵达或者登陆
4 {& g' P. W$ I0 f8 r# J
return not_reach_point unless landable(@moveto_x, @moveto_y, chase_path)( L) ~! Z2 e# V) ^
# 根据路径表格绘制最短移动路径（反向）
: s: b s8 m: O, |2 m/ I
steps = step 2 2 + 1
- w* M2 ?) h! _& {2 k; `6 Z* U
loop_times = step 27 j, @2 W+ b2 ^2 c- R
point_x, point_y = reversed_chase_point[0], reversed_chase_point[1]
' _8 d+ B7 h9 f% S1 b5 Y A, g
for i in 1..loop_times # forLoop
& W2 W- y1 | K
steps -= 2# T4 ~2 i. G' H, o) b' W
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs
" C8 m( w& C! O7 ]& M8 G
if sheet[$game_map.round_x(point_x - 1), point_y] == steps
" K5 M" H: T y+ [" U# m
reversed_chase_path.push(6)
; Y! \7 C' \4 ^3 x8 Y; p% v) {$ o
point_x = $game_map.round_x(point_x - 1). q4 ^# ~, D, f5 k1 o6 \$ i0 d
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
6 J" [' N& x& }7 f0 E
reversed_chase_path.push(4)9 P$ a( e2 ]; [ }( Z+ S$ y0 J) D
point_x = $game_map.round_x(point_x + 1)
# e" J5 w- N4 S8 u$ b
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == steps6 q6 O; K' U v1 m- x+ ?2 Y, g, r+ b3 K0 @
reversed_chase_path.push(8)2 I Y* d- G- N, V7 ^
point_y = $game_map.round_y(point_y + 1)' r" Z: D; \7 I$ f# m4 h4 T; w
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps: v- j$ P+ P' c$ i) V5 m
reversed_chase_path.push(2): A6 Y7 s+ J0 u0 [ h' K5 d
point_y = $game_map.round_y(point_y - 1)' Z, q& G& G: P' Q: P. g, y* W4 m
end
8 C6 e; d3 b5 w5 t S
else& p7 ~( z0 m/ A( L R$ x- }
if sheet[point_x, $game_map.round_y(point_y + 1)] == steps
( v2 ^5 Z# C9 S2 g% X# Z9 j
reversed_chase_path.push(8)$ Q) `+ b2 O% d, s$ v- A/ \6 U: z$ i9 `
point_y = $game_map.round_y(point_y + 1)& w6 |7 `) S+ f1 E: S6 P
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == steps0 K5 R& Q; n$ v3 t9 ]
reversed_chase_path.push(2)& S( P3 X' b% l& _. i
point_y = $game_map.round_y(point_y - 1)7 {+ b! X( o8 h* E
elsif sheet[$game_map.round_x(point_x - 1), point_y] == steps
6 e# l3 @& d' ?- p& q
reversed_chase_path.push(6)5 i3 l7 w3 u! H/ y" ]
point_x = $game_map.round_x(point_x - 1)
2 W/ Q5 I: a1 N8 g& E
elsif sheet[$game_map.round_x(point_x + 1), point_y] == steps
& I. m3 L. E) u/ t- Y8 \
reversed_chase_path.push(4)7 ~0 v: p4 f. B
point_x = $game_map.round_x(point_x + 1)
! o. r8 c+ q! x" d6 a' I
end- N% q" ]- p2 K6 b" s5 z9 p( q
end
5 V0 w8 q- `7 U8 c8 w/ A, k6 T
end #endOfForLoop4 Z5 J; X `6 u7 ~. A* W) _
@mouse_move_path = reversed_chase_path.reverse + chase_path
% i3 d0 \$ y9 h; p& T% w6 H
end#ship
5 L& C/ n4 G! S
#--------------------------------------------------------------------------' N4 o$ I* y. V8 Y/ H
# ● 绘制airship的移动路径 @array[move_directions...]' }. Q4 ]2 Z, _3 r) G5 X
#--------------------------------------------------------------------------5 J$ S1 |* d8 z4 y8 L
def draw_air_path
2 |4 }$ N2 `2 D4 B/ \+ s8 [+ p' P+ \
$mouse_move_sign.transparent = false
$ K2 i, f7 n& w4 |9 M w
# 准备绘制路径表格% v3 V. m. u+ |7 [+ s0 v3 ~# P* B
sheet = Table.new($game_map.width, $game_map.height)
; \; ~4 d+ u0 M8 k
new_check_point = [x, y]; sheet[x, y] = 1
. d' I) N( I" _, d) J) A8 ~
reach_point = false; step = 2
4 l) i) a' J2 M* j% u$ C$ V; g
loop do #loop1
( T& o5 [% S# E) |/ ^9 w6 o+ `- r
check_point = new_check_point
9 h2 p0 C. Y [6 O4 M
new_check_point = []4 J1 Z* `7 N7 @+ i
loop do #loop2
/ y2 {' s' e" p: ~- t" {! V# j4 k
point_x = check_point.shift
! d+ l0 n% T/ g! Q7 g) {* V# o
break if point_x == nil
# b7 I2 V2 V; T7 @
point_y = check_point.shift8 i& g }" c% q0 J. C6 S N5 x6 k
if point_x == @moveto_x && point_y == @moveto_y
$ a0 w2 s$ s: K( o4 ~% Y0 b* d
reach_point = true; break1 |9 y) @2 _6 J
end
7 i( _& ]8 K1 F2 D) T
left_x = $game_map.round_x(point_x - 1)" h. X ^9 [! j# g: Y6 z
right_x = $game_map.round_x(point_x + 1)
% ?- j- ?$ l! j4 s, l6 t3 j
up_y = $game_map.round_y(point_y - 1)
/ \" a9 |+ i7 B& x! U `. b
down_y = $game_map.round_y(point_y + 1) 6 F: J. j1 H- x! K) m
# 以需要抵达该点的步数填充路径表格 #
! \( `$ s% i, K$ B0 d
if sheet[left_x, point_y] == 0
7 @8 Q2 O6 t+ ~, I9 v$ H
sheet[left_x, point_y] = step
% o3 u+ f" D1 S
new_check_point.push(left_x, point_y)7 z: G. q- v( `7 J; L% U( P6 @
end
) W: E5 P \6 `/ }" `1 G
if sheet[right_x, point_y] == 02 A) o1 n. u# H8 V5 a9 c
sheet[right_x, point_y] = step
) G) ?/ I. _) `( c# _2 ~8 U0 X
new_check_point.push(right_x, point_y)7 J( u7 F" G+ w9 {# V: K) v% T
end K* Y/ {2 w+ \* A# b7 @( p) p
if sheet[point_x, up_y] == 05 f- c! n7 E Q4 r' j9 m, d
sheet[point_x, up_y] = step/ L+ H4 a9 B% ^+ O" b! J2 K
new_check_point.push(point_x, up_y)
( C$ h8 j# W6 C' T" i: S9 A
end B* Q# |! m+ q! J
if sheet[point_x, down_y] == 0# s9 C: D5 g; V8 ~% N
sheet[point_x, down_y] = step* O- }1 g2 c% A4 b1 F) Z
new_check_point.push(point_x, down_y)
' G, v/ A0 [6 F
end
# \: t# l f" Y* k. n) e/ g
end#endOfLoop21 J; ?# [ u% z
break if reach_point
% [5 r5 D4 t( z% F2 e, A
step += 1
" ~' o* @5 T! B" \4 U E" @$ ^
end #endOfLoop1
& E# x0 j( [6 U/ g, x, p5 d& t
# 根据路径表格绘制最短移动路径 #5 O# k( a% k- M
reversed_chase_path = []; step -= 18 [6 _3 f+ C8 y# v# k2 d! T
point_x, point_y = @moveto_x, @moveto_y) N. E4 j5 q$ S/ u( Z9 G* S
for i in 2..step
" `" ?5 H) C8 N H# _: S, {# I
step -= 18 X2 j) Z; A5 y9 T4 z
if (@moveto_x - point_x).abs (@moveto_y - point_y).abs- t& z9 ~$ U: P% Q
if sheet[$game_map.round_x(point_x - 1), point_y] == step
' Q! p0 e: @2 |" ] W7 `+ K. W
reversed_chase_path.push(6)/ z& P$ S. D' l8 g2 w
point_x = $game_map.round_x(point_x - 1)
% }" ?* H2 [, A. Z/ \
elsif sheet[$game_map.round_x(point_x + 1), point_y] == step6 U d) `) E# X+ {+ l% n* p" c8 E
reversed_chase_path.push(4)
- o' G r' u/ z2 j# ^
point_x = $game_map.round_x(point_x + 1)
8 Q4 A8 S# Q7 n2 G& ?
elsif sheet[point_x, $game_map.round_y(point_y + 1)] == step. ^, f* o2 g! d Q& C5 ]4 s* \$ \$ ?0 h
reversed_chase_path.push(8)- B( e9 V+ G* w+ M' h: ~1 h
point_y = $game_map.round_y(point_y + 1)
7 Q* W/ E2 O& H# ]) l
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == step
7 ~% a9 z1 s$ d
reversed_chase_path.push(2)
: Z1 n% s5 P7 a# U# N; o1 W$ d. g
point_y = $game_map.round_y(point_y - 1); }7 C6 S* T; T( j
end
# I& I! W& M G1 h
else
/ I* Q0 @4 @# J/ ~( C
if sheet[point_x, $game_map.round_y(point_y + 1)] == step
7 s. C Y* x+ o0 w7 n
reversed_chase_path.push(8)
' d9 R: ?# c; E" g) T) h4 v1 m
point_y = $game_map.round_y(point_y + 1)
5 |( ?4 c/ M# E) }! L
elsif sheet[point_x, $game_map.round_y(point_y - 1)] == step. Y# n' e. Z7 W* U, g
reversed_chase_path.push(2)- J+ U6 g9 g# @
point_y = $game_map.round_y(point_y - 1)
6 K1 T) p, H- o5 W+ S" W) i
elsif sheet[$game_map.round_x(point_x - 1), point_y] == step
Q# T g- i, L9 R) P. E4 L
reversed_chase_path.push(6); H' X( Q. _# ~+ u k, {; k* i6 l4 \
point_x = $game_map.round_x(point_x - 1)
$ f" f7 B& D. v2 ?
elsif sheet[$game_map.round_x(point_x + 1), point_y] == step
" t# |5 \4 _5 R) x+ A
reversed_chase_path.push(4)3 J! k& {3 v! L% k( T. a
point_x = $game_map.round_x(point_x + 1)
9 y: C" C9 S4 C3 N9 w' D/ u
end
- m7 J! [6 o" ]* e
end
& N+ U% F# n: A8 U' P+ W2 B; f
end #endOfForLoop : v8 T7 T2 J+ S, T
@mouse_move_path = reversed_chase_path.reverse
" x' I! M n; Q" t# K4 F
end#airship f+ Z1 P# _' y( I
#--------------------------------------------------------------------------- J$ C$ E W; s& b8 h; o0 b/ D
# ● 目标点无法抵达时的处理，用于各路径绘制方法内部
6 K$ \- o/ [; t' C/ ], w7 @: f. V
#--------------------------------------------------------------------------
$ L9 Q; ]+ p, H0 w" y
def not_reach_point* D2 m! J1 ~! n4 n8 j& v
$mouse_move_sign.direction = 4- Z4 g- k+ `+ H5 f
dx = 0; dy = 0; dir = 0. ^& [( z) u7 R8 u
if @moveto_x - x 0
/ E4 y8 C2 ^2 k N, X0 w) i
if @moveto_x - x $game_map.width - @moveto_x + x &&3 t% g+ i/ ?1 {2 t6 E; i
$game_map.loop_vertical
0 P1 n7 K# q, Q: p* @
dx = $game_map.width - @moveto_x + x; dir = 4$ l' v4 s5 O& @" K
else3 U' n7 ? Y0 @; n0 _
dx = @moveto_x - x; dir = 69 {; Q( g6 O: d8 r, _
end
# E. p9 N! o+ }* T; B, q8 r* D* s
else( ]6 m' Z+ b& y
if x - @moveto_x $game_map.width - x + @moveto_x &&) @# K, f" @9 D+ P" j' A. d3 M9 j: |) \
$game_map.loop_vertical1 ~% z; C+ a, i; L) k
dx = $game_map.width - x + @moveto_x; dir = 6
/ M2 l+ ]" }! b* p2 C
else* w9 u: {# K/ |4 T# W
dx = x - @moveto_x; dir = 4
/ l9 F, m$ J) l
end
/ @& P$ n) y1 T, j* a; n3 u
end! W# R" z2 B" m% i6 B) N
if @moveto_y - y 0
: r/ {9 X" ^. [ ~5 e6 p
if @moveto_y - y $game_map.height - @moveto_y + y &&
6 h/ N2 X5 ^. `1 U
$game_map.loop_horizontal
. G4 @2 M1 e* J
dy = $game_map.height - @moveto_y + y0 P& V) a7 u+ n! p% N u
dir = 8 if dy dx# M/ X2 l$ ~: o4 k, i( e/ a! V
else- Q; P7 T/ s# @) i( O
dy = @moveto_y - y2 N7 M8 j1 r1 L3 W( M
dir = 2 if dy dx
R9 p$ i: n6 n% Y$ ^$ Y
end
1 M* O' w1 c1 J9 N/ `3 X
else
4 o. ]9 _8 N% t0 A) c& r5 B
if y - @moveto_y $game_map.height - y + @moveto_y &&8 a3 ]6 a M+ y5 p! z( ~
$game_map.loop_horizontal& P- B- R& \1 q2 i$ F
dy = $game_map.height - y + @moveto_y
9 X+ `0 r" j) Q/ }: c Y
dir = 2 if dy dx
' r5 \" r1 i7 E/ R: h, U# ~. O4 N
else( D. x, ~6 r) |5 {1 }% Y
dy = y - @moveto_y
3 K" `+ A/ K7 d
dir = 8 if dy dx
, ?* q; e: q9 S; ]
end
! \- ]5 Y2 w. M$ V8 ~6 h
end
* |! W( M4 ^! g# s" d* K8 P5 M
@mouse_move_path = [dir, 0] # 0方向用于防止移动过程中触发事件
( c1 H. U& t! p7 e1 K
end8 T d f. g) G6 b- s9 f$ S4 d
#--------------------------------------------------------------------------
" q$ R. r* K0 o* P- g- p& {9 u. b
# ● 判断目标点是否能抵达、登陆，用于船只路径绘制" a4 P% j3 q1 a5 [
#--------------------------------------------------------------------------
$ M, A$ \! s; L" I" u& m
def landable(x, y, path): R. O. o1 U5 R. a0 x/ |5 [6 w, G4 G
case @vehicle_type
) w# o" g. k7 e$ B u, [
when ship; return $game_map.ship_passable(x, y) ) p- t/ W6 g7 \# l, S& D( D
$game_map.passable(x, y, 10 - path[-1])
4 M$ W' O5 h4 O! V9 e' L
when boat; return $game_map.boat_passable(x, y)
5 O5 y2 M' l8 P: P8 O+ }, b
$game_map.passable(x, y, 10 - path[-1]); g! t1 w$ r# W# \1 r% c
end
# m3 T2 A4 J2 H0 A. Y
end/ }" }8 X" j1 t
end' U% c, | V8 P4 F) ~+ ^
. y( O( Z, I* _& |6 I
#==============================================================================) g' `9 B) J: @9 u8 O" `- |
# ■ Game_Map
#------------------------------------------------------------------------------
E8 x: ^$ v. X$ K
# 　管理地图的类。拥有卷动地图以及判断通行度的功能。/ V, i9 g5 b8 b5 M, j1 l4 |& k
# 本类的实例请参考 $game_map 。
; O$ u4 b! g* x7 X7 e( Y' q9 G
#==============================================================================
' I9 E& \; q ^6 k
class Game_Map3 b) R _, a# Y$ A6 l8 x( L
#--------------------------------------------------------------------------9 M# H* A! E3 _9 P' t7 m7 S/ [
# ● 定义实例变量& c( [, N" Z2 Q- ~$ X' Y0 x! h
#--------------------------------------------------------------------------9 {9 ~/ R9 [* {1 E
attr_reader mouse_map_x # 使用前需先使用 get_mouse_map_xy 方法来更新数据8 W) }7 }( O) Q% d6 P+ B! F' l! F9 d
attr_reader mouse_map_y # 同上
0 {4 k+ m5 t) p" J4 r/ D
#--------------------------------------------------------------------------1 _8 f) s2 x0 L6 h( V
# ● 初始化对象
- K K. I0 c T0 p' m
#--------------------------------------------------------------------------
4 Q2 E/ z+ _2 T4 w+ e. Q$ w% Q
alias sion_mouse_initialize initialize, W4 g \& e4 p% o6 ~
def initialize
: {. E4 L/ g' W' S% o0 s" [
sion_mouse_initialize, u) s7 d& E/ a6 @
creat_move_sign ###
6 y* L4 j' {" v
set_constants
4 f8 D7 i( s9 }, `# @ L- L5 }
end4 q7 Q) B( C" G
#--------------------------------------------------------------------------
# }) Z$ Z2 g+ @! r1 _% U
# ● 更新画面1 h$ [" K# G4 t6 m- x/ ]' P
# main 事件解释器更新的标志/ r1 }+ l& o3 U% t' P. M* m8 y
#--------------------------------------------------------------------------$ K6 }+ R0 d/ b
alias sion_mouse_update update6 G2 ?# U- q! Z3 P
def update(main = false)
: e# ?7 v& f& ?4 g2 F9 }
sion_mouse_update(main): T2 ?2 k4 x6 M: ]* Y
update_move_sign
" U) y+ {7 U' L9 n/ {' {3 C
end% J0 B* }: x7 v. |0 e3 n6 `
#--------------------------------------------------------------------------* z" ~; Z4 l6 Z- a& L k
# ● 创建显示路径点的事件% B% e3 C, w u7 ~& n, a& R' r) c
#--------------------------------------------------------------------------
4 \2 z6 S5 B4 l( I, f, o8 d) z2 a
def creat_move_sign
3 w- v2 H0 T$ O% G. O
$mouse_move_sign = Move_Sign.new
$ z" x. X! D7 Y0 G& X7 ~
end4 s# c6 ?/ d4 M' _* H
#--------------------------------------------------------------------------
* y8 p: {" Y8 M/ }# u$ N- [
# ● 更新显示路径点的事件% H8 B/ w c3 O5 S& V( S
#--------------------------------------------------------------------------
5 A3 d/ R# x [( B8 [
def set_constants
7 T+ ?% U; X: \, V2 U; U k
@mouse_pos_setted = true+ a0 F' h% O1 {2 @ P! t
@set_pos_prepared = false2 k W7 s0 s0 D& @ V
@mouse_old_x = 08 H# o. p" C. u4 C6 `4 w: B
@mouse_old_y = 0: I( P/ o# t. j- O
end9 o5 d9 i6 ~: g) Q6 y
#--------------------------------------------------------------------------8 @5 h0 }7 D# \; N" l
# ● 更新显示路径点的事件
; V2 H0 t: B, \- X" ?& \. l8 J
#--------------------------------------------------------------------------
3 B2 R4 u; l9 y: T# v
def update_move_sign- u' h* ? L. X* B; Z0 q1 d
$mouse_move_sign.update) Q* M) Q9 H8 H
end
2 |, u8 S7 {4 Y2 T( V
#--------------------------------------------------------------------------
# w: k5 _# m2 A/ c5 \
# ● 获取鼠标位于的地图块的x、y坐标
$ w e/ [1 i* S% l# o
#--------------------------------------------------------------------------
9 J; V" J& W. p% a7 N; b
def get_mouse_map_xy, U8 |% i1 g3 e( P" L* l' {6 G
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y( e" F% v K7 Q2 x
@mouse_map_x = round_x((@display_x + mouse_x 32.0).to_i)
) V2 }$ h/ g/ f
@mouse_map_y = round_y((@display_y + mouse_y 32.0).to_i) s8 [3 E0 Y! F; Q+ S& l
end
: g& _9 n0 G) Q8 N4 D
#--------------------------------------------------------------------------
Z3 l/ L" x* O" J0 ^5 b
# ● 返回地图画面时重设鼠标坐标
9 p9 N+ B9 n1 M J% E$ C) F3 |$ B
#-------------------------------------------------------------------------- p. a1 q$ a: p) f7 r, G
def reset_mouse_pos6 W4 ]- q9 X# x5 |# I2 Y& N
return if @mouse_pos_setted
. X7 @" q; E: I7 v9 n& ~8 K+ e# G6 n
Mouse.set_mouse_pos(@mouse_old_x, @mouse_old_y)
" X1 N8 j4 ~$ V O8 G" \8 q; t
@mouse_pos_setted = true
: V; i5 ?! v, a2 T# T/ @
@set_pos_prepared = false* z8 r& W- t0 Q$ v9 ^6 @4 Y
end
. Q# H9 f: \/ q) T1 i2 d
#--------------------------------------------------------------------------
% r7 g. q3 m. D- f) {! [. J
# ● 重设鼠标的坐标 ^/ s# }+ g9 {, P S$ A
#--------------------------------------------------------------------------, H1 H5 H& Q/ o7 E4 t0 ~- r
def prepare_reset_mouse_pos
; c9 [$ d4 v% d9 L% p
return if @set_pos_prepared
$ L% I$ ?9 _) [- I
@mouse_pos_setted = false
1 ^4 [; s4 x6 M. n; \+ m
@mouse_old_x = Mouse.mouse_x! y& F( ?1 o# S
@mouse_old_y = Mouse.mouse_y
7 [% D1 {# n3 x |
@set_pos_prepared = true' z6 l/ L8 C8 ]) B, T: O4 Z$ U/ W4 u# p
end
. [# {( S/ _- ]2 m: Q' V
end
8 H* _5 B# g; b6 ?" u3 o, Z9 Z% Z2 Z
! ~$ `8 V9 @4 x' Z$ K4 l
#==============================================================================
0 h, m; M* c" _/ R$ A
# ■ Spriteset_Map
: w9 t8 g" l e; g3 Y- d
#------------------------------------------------------------------------------
: W8 A R0 B; B) p8 g- f
# 　处理地图画面精灵和图块的类。本类在 Scene_Map 类的内部使用。
& L& r9 c! ~7 L( t' S) n: s) Q
#==============================================================================
* F! S9 Y+ @5 K7 {
class Spriteset_Map9 [/ P. f. [, a7 Z2 `5 c
#--------------------------------------------------------------------------
9 c5 B7 F2 @- m# c
# ● 生成路径点精灵- f7 ~, ^3 k2 E V
#--------------------------------------------------------------------------: q6 P9 |' m# }1 X& J0 B2 s1 G
alias sion_mouse_create_characters create_characters
( b6 m( E3 \! c# O8 e5 W! c
def create_characters
4 M k0 |+ e% _! o
sion_mouse_create_characters! |/ |9 l( q- V+ r
@character_sprites.push(Sprite_Character.new(@viewport1, $mouse_move_sign))2 ?8 Q6 e8 ]! ]- w! L: }3 p% i
end& h* e" U9 R, G% v" A
end; `0 Q5 M$ l3 J: E8 \9 f
" Q! o* `1 y0 r4 w, ~' f$ T/ J
#==============================================================================7 a( d$ k% k3 f5 m* [2 c
# ■ Scene_Map
9 E5 g( z' w! G6 r1 t
#------------------------------------------------------------------------------- M6 |& E: D8 w" d; b
# 　地图画面
a2 G, |5 P& L' T4 c
#==============================================================================7 i; a$ j. i) o" G. U
class Scene_Map Scene_Base; ? \+ S0 p! Q6 t) j' n1 ~
#--------------------------------------------------------------------------
) l6 F( \8 B7 B( Z0 U+ m0 A
# ● 画面更新
: q( U4 c. q X) e
#--------------------------------------------------------------------------5 Y* M }! ^" r! v
alias sion_mouse_update_scene update_scene
, x) J+ ~, Z6 [- ]% O( v6 g0 w. b8 u
def update_scene
3 N' {1 h5 ~0 I
sion_mouse_update_scene
! z9 {$ n: T' Y* M0 `. j" S: i, ]( C
update_mouse_action unless scene_changing
. j, t4 X" j, w
end3 Y1 M% i' B& C- s# s" ^7 p
#--------------------------------------------------------------------------
3 C: D8 j5 z. h* w+ p
# ● 场所移动前的处理
' j- b ]% A* Y6 |3 ?# @7 O
#--------------------------------------------------------------------------; q# O2 D Y2 \& I6 m
alias sion_mouse_pre_transfer pre_transfer, i8 r3 y2 P: V, C3 ?: ~" e
def pre_transfer
5 \$ n0 _8 Y, e% x! x
$game_player.reset_move_path8 A" D. e# B7 ^$ S1 a* ?* z
sion_mouse_pre_transfer# [: q1 N) o/ E0 Q
end q: p) O9 e1 H2 g/ _! J$ K
#--------------------------------------------------------------------------
2 I& ?. `% K) M5 s6 {3 {6 r
# ● 监听鼠标左键的按下/ H. C. b: i0 J# x
#--------------------------------------------------------------------------6 h2 E7 p; r+ f5 n
def update_mouse_action- V4 u9 I* K/ ?. z$ R& }0 _8 o K
$game_player.left_button_action if Mouse.press(0x01)
) w* g3 I1 {7 C
end# C8 m! E4 B& V- b) ~, I" C L" |
end- c) d, O+ i& q2 v8 j4 R4 }8 {- ?
6 G1 D: t- p# H! e$ E
#==============================================================================* a- y6 r+ s5 L5 G G2 x. _
# ■ Scene_File
: Y2 ]9 a6 d9 K4 {. M
#------------------------------------------------------------------------------; X# q# d- P5 A" f& f! L) ]
# 　存档画面和读档画面共同的父类 f8 Y8 f( t5 }' Z: Q% P1 i, ?
#==============================================================================
* v/ y0 G' Q2 G- g
class Scene_File Scene_MenuBase$ j' q, D9 d/ Z# W; J6 X8 o/ v+ f
#--------------------------------------------------------------------------8 N- h& j% \* F7 [ V! w8 H
# ● 开始处理
# T* I/ R: z8 ?- H# k
#--------------------------------------------------------------------------
* ]) J2 ^6 ^5 t" t6 ^4 N* f z( Z
alias sion_mouse_start start
. Y+ o9 U/ u/ F a
def start
8 b4 B8 ~! m" R7 o' o2 }
sion_mouse_start
& L6 \+ I& J+ k+ z, p- s0 k+ D
@move_state = 0 ?$ m7 l7 g6 b- ^# G
set_mouse_pos, c& ?5 P2 ?/ T) Y/ _0 l) z
end: c6 C4 `& g+ {
#--------------------------------------------------------------------------
; z. h; u4 P0 k/ O+ G6 L0 [
# ● 更新画面$ n, l8 a& x+ k' S% t4 V
#--------------------------------------------------------------------------
& C+ V; O' N% a5 t; X) t
alias sion_mouse_update update
2 t- [& H6 ~# h9 e# v
def update
1 t% K3 [$ I3 m! X9 u" r, ^0 b
sion_mouse_update
& ^& f3 S4 ~- T W. ]5 d
Input.dir4.zero set_cursor set_mouse_pos( S; b# _+ h& a$ A% l9 E& v l
end
$ e+ c2 F; H% I+ V0 n4 G2 _
#--------------------------------------------------------------------------
# B& ^9 Z/ a6 I) u) g& b4 I
# ● 更新光标
- G% c& I* y) R9 g
#--------------------------------------------------------------------------( Y3 B* n/ {& Q- E% G
def set_cursor
8 o/ i( P, M( N# d
@move_state += 1
5 T5 n5 d7 Q" [ M* w c+ P4 |
last_index = @index
: e! |% R9 h9 l6 d& R& J
if mouse_which_window == -2/ P+ }- z7 {% f# d2 z
if (@move_state - 1) % 6 == 0
W4 y8 y8 Q1 X# d
@index = (@index + 1) % item_max if @index item_max - 1
6 ?% M4 _4 ~ Y' d9 l" h( N
end8 ^' A, N+ l1 q! q
elsif mouse_which_window == -15 m" h6 o0 j2 s1 `
if (@move_state - 1) % 6 == 0. I% X5 }8 @* J2 K; X5 ~- ^6 _; P
@index = (@index - 1 + item_max) % item_max if @index 05 f* l# G7 i) N/ d" K0 `! l2 ]! Q, o& I
end, u! k& S* J) U) J. d7 ]
else% I( H" ~/ `3 ^+ {/ j
@move_state = 0& E6 J* I1 y! m
@index = top_index + mouse_which_window+ u3 r- q& R3 \; y Q/ b d
end
1 p! _- T' Q* C1 m& r- y0 v3 N
ensure_cursor_visible, o: P8 K: y9 r! W$ G2 T: V
if @index != last_index
; ?( X5 H# B' s, f! a) r
@savefile_windows[last_index].selected = false
: W7 q: q: J: s* V, r: b2 E: s
@savefile_windows[@index].selected = true
' `4 e0 }, e5 h
end+ n, G' R# e* ~8 g3 ^) D
end
1 j8 |% g3 {& W; ~! I- C+ {' ?
#--------------------------------------------------------------------------/ { a0 k2 [4 [4 ~ g
# ● 判断鼠标位于哪个窗口
8 @; G7 Z) ^' ]$ O: l! J
#--------------------------------------------------------------------------1 X( i* E1 x- Z7 }
def mouse_which_window
& q. z) a5 N1 C7 B5 l
mouse_x, mouse_y = Mouse.mouse_x, Mouse.mouse_y" J9 B1 [) H0 w0 {% \1 ~
if mouse_y @help_window.height + 14 Y, f" Y V; \) X! A
mouse_row = -1
4 [: h; j; [' f4 W' u+ M1 a
elsif mouse_y Graphics.height - 143 r5 V- r+ z# v4 h# C: M
mouse_row = -28 ^. |7 M. \. _7 n4 F
else* u$ x$ w4 Y, X! d9 O& \. A$ H
mouse_row = 4 (mouse_y - @help_window.height) 5 D1 L0 |( s1 h: _
(Graphics.height - @help_window.height)
* `9 W% E F! [; S4 B* i
end
. J, W) {) o# D Z+ E
return mouse_row
) s0 z/ h! E& x3 z5 M @
end
0 m1 ~! X& A- |2 A7 S4 \
#--------------------------------------------------------------------------
* d& B9 x7 ?' d
# ● 方向键移动光标时将鼠标移动到对应的光标位置
- _+ ?& N0 c; h- a+ G
#--------------------------------------------------------------------------6 w) ]5 L2 ?$ `. N9 L
def set_mouse_pos8 [+ N! _" C d8 \% d$ e- u8 k
new_x = 40' @, a: S7 ` c7 M5 F
new_y = @help_window.height + savefile_height (@index - top_index) + 24
- b% h2 a% c4 t! }0 g
Mouse.set_mouse_pos(new_x, new_y)
4 t6 i: _& a' E( m6 p( h4 C
end$ k, }8 f' u5 d% R9 b
end
; k# s) g+ c" P5 C
( E, w: v- r- \) r$ n+ \
#==============================================================================
% S( W, J5 c" O5 R( N
# ■ Game_Event
5 _/ t& N3 e+ F6 f
#------------------------------------------------------------------------------& Y' |7 f/ g) o$ A I
# 　处理事件的类。拥有条件判断、事件页的切换、并行处理、执行事件等功能。5 y, N! A9 R/ B) o' e2 m
# 在 Game_Map 类的内部使用。. A) @- ^+ y5 Z* b3 @
#==============================================================================
* p# C. r7 D% j
class Game_Event Game_Character$ l& s% l% R ~, U3 j
#--------------------------------------------------------------------------9 Y( `3 f0 D: O
# ● 事件启动8 @+ U- ]% l: Q; ?
#--------------------------------------------------------------------------" [; L4 s4 m. A5 F
alias sion_mouse_start start7 e1 c% W. s$ V( H% B" G
def start! c8 v+ }; \+ ]$ Y' O" G
return if mouse_start && !Mouse.press(0x01)
! T8 J) C' a5 b* Z
sion_mouse_start
% w: {. `( f9 e8 z! J
end
! @+ u2 C- p+ Y6 |; J7 d
#--------------------------------------------------------------------------
$ J* E; g6 h/ v
# ● 判断事件是否由鼠标启动
, k2 D4 v4 O4 e S6 I
#--------------------------------------------------------------------------+ A. n x) K5 I
def mouse_start
7 h/ b2 P6 D, g7 U6 r7 Y
return false if empty
5 a8 O# E" l0 @4 F6 ?
@list.each do index
* t1 u) I; t; F& A0 M' X6 J
return true if (index.code == 108 index.code == 408) &&
) B: w9 p% K) x1 m
index.parameters[0].include('鼠标启动')
+ ~% U3 s" o6 _6 c9 o& w. l
end
2 Y2 g2 k0 Q% G+ \# s
return false
! ?2 O% T( T, E0 ~9 I
end8 `8 q8 a' Q' Q* d: w
end
9 H% G* C' y! O5 w3 R( p" \
- o4 k1 O# h8 v3 q! l% O
####泥煤的height: i9 I" G# ^, p' k6 a
# @height = height" `* w X$ T: \; V
: X6 w% k- l% g* B# O- S
class Area_Response* V4 _" S4 R. z2 d$ E, x q7 f
attr_accessor type( p* }0 _' w- H w; W
attr_reader ox
7 r; e% e+ l# \
attr_reader oy
1 j. s6 J; q& g# b! y, S
attr_reader width5 ]8 C7 H6 R2 _$ u1 i
attr_reader height
" @8 h2 q; x/ O* s( \+ H% k) {
attr_reader switch_id
r$ y6 J8 e" w
def initialize(type, ox, oy, width = 32, height = 32, switch_id = nil)
8 Q, _1 b7 j* N( ^
@type = type
# r0 [8 {/ O0 E, c, m5 X
@ox = ox( F$ u- i% |: s7 C& t
@oy = oy1 y4 w5 z) \! [; X# E- D: I
@width = width0 b5 F C8 A" ~
@height = height
9 i. o: _" J$ G/ w
@switch_id = switch_id; \# r/ P! q; E
end: S% h3 ?4 l. ^! H+ ?5 I9 D
end% d5 ?2 B5 M. `6 V: A8 Y! Y
! V" [1 ^' Y2 H9 X. m7 x0 E
$area_responses = []
) W4 @, i5 M0 ~" M& ^( l* t
5 x9 @. {. z$ X5 I: I- G
class Scene_Map3 ^8 f: V9 v) T" O' m6 k9 A2 E
alias update_mouse_2013421 update_mouse_action
; p' m: W5 N9 J7 p8 Q
def update_mouse_action* R" f- w7 ^; l; z, F& r" l6 b
update_area_response
, e: O, U* j: C" j" U
update_mouse_2013421) L1 ~* h% ^/ M$ v$ F( L8 h
end+ w/ u' p7 Q' {) T
def update_area_response
( a) z& ?! A0 T: a
responses = $area_responses
3 U( z: X- l9 Z4 d/ q/ a( n
responses.each {response
: c: \; J* [2 @" O$ c4 H/ q
ox = response.ox
* |) G& N/ h( _; |3 e P# N4 ^
oy = response.oy
7 a- k O, Q& w8 [
width = response.width
, ?3 F" H; R/ ]- Y+ z
height = response.height; Q7 n+ H7 U" @; J
switch_id = response.switch_id$ x/ C: _- C2 o8 s
case response.type3 O) f! l# E7 A3 w* Y& l7 k
when 0- f( y! R! v' u& X4 E& A
if mouse_in_area(ox, oy, width, height)
3 w1 E# e+ O3 [, M7 u" u* `
$game_switches[switch_id] = true
! F8 i E6 n4 y; b% M2 i
$area_responses.delete(response)
$ \: L( d5 o# b
end
; T( v' |: A$ G W: H! Z1 W
when 1
3 l2 P& G2 P% o0 A
if mouse_in_area(ox, oy, width, height) && Mouse.trigger(0x01)
# V, ~0 u( T+ B" ^6 W8 W5 \
$game_switches[switch_id] = true
/ K# D6 Q& Q7 b ~/ C( n. m
$area_responses.delete(response)( ^2 G& @# H- Z9 C( ?' P% l+ H
end
* y# G! H! h( \: e+ G
when 2
" G" W! g& Y; t/ X
if mouse_in_area(ox, oy, width, height)
; d- x- K8 G% ~# W& `9 s
$game_switches[switch_id] = true& x2 q8 m) g8 x1 R. p
else8 }0 v3 k: M4 @" N- f% b; Z, v
$game_switches[switch_id] = false: X/ }% r% w4 N6 u; i/ n# L- s
end
$ T, `- i0 A- B# l% ?( r6 ]: c
when 3) q+ @) W; A, T6 u1 M) S8 B) o
if mouse_in_area((ox - $game_map.display_x) 32 ,, l" k& u. z/ i
(oy - $game_map.display_y) 32, width, height)
1 O" ?1 c9 X# |1 G
$game_map.events_xy(ox, oy).each {event: Z& r; F! `4 I+ B8 K" A
event.start( O+ ?& p! B6 O7 Z, c& Q1 [
$area_responses.delete(response)
1 [! f0 @' ~: l K, a! v
return) S: [3 ^: X) X
} & E) O9 o! L1 E( B& U1 ^& V. A0 a6 i
end/ Q) R- H, I+ P- i5 v
when 4
: N6 M# A) F0 S
if mouse_in_area((ox - $game_map.display_x) 32,
7 N w$ [7 O% R; k8 P
(oy - $game_map.display_y) 32, width, height)) F, e' }, x1 D6 }& h9 K
$game_map.events_xy(ox, oy).each {event
* q9 L7 s% o* J4 X
event.start
/ l! h% F7 C; A! D8 |
return
& b2 `" o# \. R# Q" W3 V4 b
}
7 }- @) `& b2 l8 A6 D
end6 o) a4 {' ~+ Y# S! q6 I! D
end
0 K1 C) C9 }0 s( H+ e) E% T0 p; B
} q) x$ \% z$ }) [) G4 c
end# K! _! k" _& }7 b6 Y- R
def mouse_in_area(ox, oy, width, height)
8 y8 n: X3 H0 N* q7 I- v
Mouse.mouse_x = ox && Mouse.mouse_x = ox + width &&
+ P3 `; D* N, \7 G- y- f7 O
Mouse.mouse_y = oy && Mouse.mouse_y = oy + height
# J5 |& Y2 s1 ? [6 k/ A8 f
end' L, W) ^. C6 D( M5 ~8 O2 s
end; K7 |9 c) A, L( M d Y( N
class Game_Interpreter
9 y/ j {% j/ _% ?7 w+ W0 x, D
def area_response(arg)3 W- [, \, t- E& R2 `1 s
$area_responses.push(Area_Response.new(arg))- }! X: B: i5 ?1 E$ o1 [
end
, M( p0 M7 v7 K
end
/ O) Z8 ~8 z, H: |( _- ~

复制代码

帐号		自动登录	找回密码
密码			注册会员