存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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