存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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