存放腳本

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

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

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

x

純屬給LBQ腳本:

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

复制代码

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