水面动态倒影，求解

禺谷皓月

[code][/code]
这个代码怎么用啊，有大神知道吗。我从国外找的。
. `* R# i& D  V) J0 {1 q# {http://galvs-scripts.com/2013/02/21/character-effects/
( ^0 j) ]  O, v% t是关于动态倒影的

禺谷皓月

1. #------------------------------------------------------------------------------#
   ) |3 {( n9 A9 \( K/ P
2. #  Galv's Character Effects
   * x  [0 P; R: Q
3. #------------------------------------------------------------------------------#
   ! A) H6 Z9 {8 ~
4. #  For: RPGMAKER VX ACE
   , E, j# B& N2 z3 r9 `8 p7 j$ g6 q3 H
5. #  Version 2.1
   # ]/ t7 e' H- z* c) @
6. #------------------------------------------------------------------------------#
   
7. #  2014-01-16 - Version 2.1 - Fixed double balloon/animation bug with shadows
   
8. #  2013-12-07 - Version 2.0 - Added comments to more easily add event effects
   / q! Z) J0 q! @7 f6 k2 A
9. #                           - Fixed shadow facing bug
   
10. #  2013-02-24 - Version 1.9 - added z level option for reflection and shadows
    
11. #  2013-02-23 - Version 1.8 - added multiple light sources for shadows
    
12. #  2013-02-22 - Version 1.7 - bug fixes
    ' C! \6 }! E. ?- a
13. #  2013-02-22 - Version 1.6 - added icon effect
    : z  M+ v8 \- z+ a. u$ t
14. #  2013-02-22 - Version 1.5 - fixed mirror bug on large maps
    
15. #  2013-02-22 - Version 1.4 - added effects to vehicles
    ; F  q8 L3 y; H
16. #  2013-02-21 - Version 1.3 - fixed jump reflection and other minor tweaks
    7 g. w: a3 a/ U8 e$ P/ M0 r
17. #  2013-02-21 - Version 1.2 - bug with less than 4 actors (oops)
    4 E% X2 X( n7 |: H) L) S, I$ N
18. #  2013-02-21 - Version 1.1 - updated flicker effect
    1 y9 j. ?2 ~" Y5 Q9 F- O  c; l% ?* v
19. #  2013-02-21 - Version 1.0 - release
    ' b5 e) B) m" E  A! J3 k: Y
20. #------------------------------------------------------------------------------#
    
21. #  This script was made to provide some additional effects for characters such
    ) b" L% b: [0 e
22. #  as events, followers and the player on the map.
    8 [5 ]( u$ I, ?# A5 U0 S7 x
23. #  Currently it includes:
    ( B) Z  p( y& b1 m
24. #
    6 X& |, d9 ]8 l( h  B; N7 p! t
25. #  Shadows
    / t; c* r+ U8 s1 E
26. #  Shadows that appear under player and events in a directions depending on
    
27. #  a light source that you choose.
    
28. #
    
29. #  Parallax Reflect
    
30. #  Reflections that appear on the parallax layer for events and actors to be
    - J1 z+ O5 m, K, y
31. #  used for things like reflections in the water or glass floor etc. To get
    # F$ \9 u+ b9 r' g4 l7 i* a
32. #  effects like the demo, you need to edit the charset graphic to make the water
    8 L# H# l$ c# e# G6 Q3 \
33. #  partially transparent.
    & E0 L- ~9 W4 O' q  x
34. #
    ' T* D# l- F2 G( i# ^
35. #  Parallax Mirrors
    
36. #  Much like reflect but are instead actors and event are reflected in a mirror
    8 O6 n- D0 X' y, y' T* X9 T
37. #  on a wall designated by a region. Both mirror and reflect effects can be
    
38. #  changed so actors and events can use different charsets for their reflections
    
39. #
    
40. #------------------------------------------------------------------------------#
    
41.   
    
42. 
    % F) {/ u9 M5 A: m  z; v
43. #------------------------------------------------------------------------------#
    ( x, X, J% E) W  U* J* G- k2 L  B' Z
44. #  NEW - First event command as a COMMENT
    
45. #------------------------------------------------------------------------------#
    " J  p. d3 Q3 t* K4 R
46. #  You can add a comment as the first event command on an event page to set if
    ! Q0 O  M5 x& T8 D
47. #  that event has an icon, shadow or reflection active. The tags to use are
    
48. #  below, all must be on the same line in the comment.
    # g# g' g" C% o! G+ i$ n
49. #
    - z9 K7 W. {* y, M( g$ v
50. # <icon:id,x,y>      # set the event to display an icon (x,y position offset)
    " T' B" T1 o. v0 ]! o
51. # <shadow>           # set the event to display a shadow
    - X# _+ @$ E. M+ g! j
52. # <reflect>          # set the event to display reflections
    
53. #
    0 ^4 M3 A' e2 C* v$ t! v: w
54. #------------------------------------------------------------------------------#
      y# _% |- r) T2 H& U3 n9 [
55. #  EXAMPLE:
    
56. # <icon:1,0,0><shadow><reflect>    # to show reflect, shadow and icon 1 on event
    3 B" q. d, ~+ R# m/ L
57. #------------------------------------------------------------------------------#
    % V( K: H7 p$ ~
58. 
    3 F" ?. ]+ C: N9 B$ s
59. 
    - @5 r0 |2 O% n6 j* s
60. #------------------------------------------------------------------------------#
    1 p+ V6 U3 |* b" i$ ~! p
61. #  SCRIPT CALLS:
    
62. #------------------------------------------------------------------------------#
    
63. #
    
64. #  char_effects(x,x,x,status)
    
65. #
    
66. #------------------------------------------------------------------------------#
    3 e+ N% P' B9 l" P8 ~- Y0 J
67. #  # each effect can be true or false to enable/disable them during the game.
    9 C) W9 `+ s" {% M
68. #  # you can change multiples of effects at once, x being the effect number
    
69. #  # 0 = reflect    1 = shadows    2 = mirror    3 = icons
    # Q% g# O' ~$ Q; q/ ^! a8 R& g) D
70. #------------------------------------------------------------------------------#
    
71. #  EXAMPLES:
    ( e; g( Z" p" w) T; L& M
72. #  char_effects(0,true)              # turn reflections on
    
73. #  char_effects(0,2,true)            # turn reflections and mirror on
    9 l/ P) A& ?. ^/ K
74. #  char_effects(1,3,false)           # turn shadows and icons off
    
75. #------------------------------------------------------------------------------#
    
76. #
    + e, C8 U& U. n/ ]. f) T
77. #  reflect_sprite(actor_id,filename,pos)    # Change actor's reflect charset
    9 _# L( x( c3 ?
78. #
    
79. #  reflect_esprite(event_id,filename,pos)   # Change event's reflect charset
    3 n8 M3 f' Y$ u: m5 [( b$ z
80. #
    2 r# ^9 w3 m( |% R! e
81. #  reflect_vsprite(vehicle_id,filename,pos) # Change vehicle's reflect charset
    2 _) P3 i! B) A2 s; b
82. #
    ' I3 x, }; {9 |& A9 P: V* l
83. #------------------------------------------------------------------------------#
    
84. #  EXAMPLES:
    
85. #  reflect_sprite(1,"Actor2",2)      # change actor 1's charset to use sprite
    3 O" x- Y$ L" V9 R
86. #                                    # in position 2 of "Actor2" charset.
    & L& r& ]6 u" _! Z& y% s
87. #  reflect_esprite(3,"Actor4",5)     # event 3 will use sprite in position 5 of
    
88. #                                    # "Actor4" charset.
    
89. #  reflect_vsprite(1,"Vehicle",5)    # Ship will use sprite in position 5 of
    
90. #                                    # "Vehicle" charset.
    
91. #------------------------------------------------------------------------------#
    
92.   
    1 S% E/ R; q/ `* c  s! _) `
93. #------------------------------------------------------------------------------#
    
94. #  SCRIPT CALLS to turn effects ON or OFF for chosen EVENTS
    
95. #------------------------------------------------------------------------------#
    . v0 g, H* n- c3 X4 t6 w
96. #
    
97. #  reflect(x,x,x,status)   # status can be true or false to turn on or off
    ' Y6 |# W% g2 A" \" f# t. G
98. #                          # use this to specify for mirror and reflect.
    
99. #  shadow(x,x,x,status)    # where x is the event ids you want to change
    * i5 b! O" I3 e, g
100. #                          # to change all events use :all
     
101. #  icon(x,x,x,icon_id)     # set which icon id to appear above character. Make
     " {5 u, ~5 P8 K5 r
102. #                          # it 0 for no icon.
     ; H! H0 k! p0 N. Y- ~( i
103. #
     
104. #------------------------------------------------------------------------------#
     5 ]3 ]9 \6 T8 ]! x4 V5 Z* j
105. #  EXAMPLES:
     
106. #  reflect(14,17,3,1,true) # Turn events 14, 17, 3 and 1 reflections ON
     8 m' Y- ~% k  K9 M7 L4 N! ^
107. #  shadow(1,false)         # Turn event 1 shadow OFF
       }# Z( F8 `; G' t+ F. j
108. #  reflect(:all,true)      # Turn all event reflections ON
     6 ?3 A% |; G# S7 ^
109. #  icon(1,2,3,4,38)        # Events 1,2,3 and 4 will have icon 38 appear
     
110. #
     # d) q; {* X8 c9 w6 g5 q$ j
111. #  NOTE: All events will default to NO shadows and NO reflections when entering
     
112. #        a map. This is a design decision to try to keep lag to a minimum. You
       c" v- S4 s; Z. I/ |4 O* q
113. #        should use these effects sparingly and only activate them on events
     4 Y' \$ c+ U* f7 d6 i# O5 e2 a$ |& \
114. #        that require them.
     
115. #------------------------------------------------------------------------------#
     3 k2 b0 H! |2 p! R( t6 Y% c0 ^- N* W
116.   
     
117. #------------------------------------------------------------------------------#
     2 t1 V; _; e4 G& J7 t( M( E
118. #  SCRIPT CALLS to turn effects ON or OFF for ACTORS and VEHICLES
     
119. #------------------------------------------------------------------------------#
     
120. #
     
121. #  actor_reflect(actor_id,status)  # reflections and shadows are ON by default
     
122. #  actor_shadow(actor_id,status)   # for actors and vehicles. Turning them off
     ' [* ]5 s/ e: F; K' J/ z# s
123. #  actor_icon(actor_id,icon_id)    # or on will permanently change them.
     , K* U9 n1 ~$ B. \# n$ j1 {
124. #
     4 G$ J0 x; L+ C2 m3 w9 m0 H
125. #  v_reflect(x,x,x,status)    # use these v_ calls for changing vehicle effects
     $ N$ b0 [$ [. S
126. #  v_shadow(x,x,x,status)     # on and off for vehicles.
     4 G  t- E  I: x
127. #  v_icon(x,x,x,icon_id)
     
128. #
     & [( N/ U/ n8 d& E
129. #------------------------------------------------------------------------------#
     
130.   
     , t  X" P/ ]5 l4 |
131. #------------------------------------------------------------------------------#
     9 F' O* ?# B4 ^; J+ f6 f
132. #  SCRIPT CALLS for shadow options
     
133. #------------------------------------------------------------------------------#
     
134. #
     
135. #  shadow_source(x,y,id)       # set the x,y location for the light. id is the
     : W+ v. c- \9 B- d0 R6 ~
136. #                              # light source number you wish to change (for
     9 H4 ^/ a3 S0 \1 c# Z
137. #                              # more than one). These are reset on map change.
     7 X: h# H) S6 O/ Q  {9 j7 }
138. #  shadow_source(event_id,id)  # use an event's x,y location for the light.
     
139. #                              # This will need to be in parallel process if you
     
140. #                              # want it to be a moving light.
     3 W1 a! p) k: ]( j+ p; C4 q, y
141. #
     
142. #  shadow_options(intensity,fade,flicker)    # descriptions below
     
143. #
     , [  d( {) e. w+ I( `
144. #    # intensity = opacity when standing next to the light source (255 is black)
     % n$ I& m1 v7 I  b# e4 I
145. #    # fade = amount shadow becomes more transparent the further away you are.
     
146. #    # flicker = true or false. Shadows will flicker as if being cast by fire.
     
147. #
     
148. #------------------------------------------------------------------------------#
     ! A; d! V; v! s' u. Y2 N
149. #  EXAMPLE:
     $ n9 y" L9 w* |1 j
150. #  shadow_options(80,10,false)    # This is the default setting.
     . j+ l7 D. _8 q: s  q2 B1 C
151. #------------------------------------------------------------------------------#
     3 l  |' m8 R0 D5 s& G( q" n" G
152.   
     
153. #------------------------------------------------------------------------------#
     
154. #  SCRIPT CALLS for reflect options
     / u. y- a5 \/ F1 {! Q, V; _, N9 k
155. #------------------------------------------------------------------------------#
     
156. #
     ) D. t" i& `* Y
157. #  reflect_options(wave_pwr)
     
158. #
     
159. #    # wave_pwr = how strong the wave movement is. 0 is off
     4 J5 }0 Q$ C) m7 y2 d/ m
160. #
     ; _$ A5 D& ^. i! X: a) a3 p
161. #------------------------------------------------------------------------------#
     # \2 f  l! R* z
162. #  EXAMPLE:
     ) z6 M% V  O2 w2 ~# a% f
163. #  reflect_options(1) # Turn wave power to 1
     
164. #------------------------------------------------------------------------------#
     
165.   
     
166.   
     
167. #------------------------------------------------------------------------------#
     
168. #  NOTETAG for ACTORS
     * G% ^% H% `. N6 t2 x
169. #------------------------------------------------------------------------------#
     ! v$ T1 v/ e  U) P2 y
170. #
     
171. #  <no_reflect>    # Actor will not have a reflection (for vampires of course!)
     
172. #
     " f  L8 O' N9 B3 ]
173. #  <reflect_sprite: FileName,pos>  # Actor will use this charset for reflections
     
174. #                                  # and use the character in position 'pos'
     
175. #
     ) ]; h  |# _" j; x' b3 \
176. #------------------------------------------------------------------------------#
     $ n! a4 J1 p4 M8 ]/ `  v& v
177. #  EXAMPLES:
     3 i" [" a5 K$ A. I9 e4 z
178. #  <reflect_sprite: Actor2,0>    # The first character from Actor2 charset
     
179. #  <reflect_sprite: Actor3,7>    # The last character from Actor2 charset
     
180. #------------------------------------------------------------------------------#
     
181.   
     
182.   
     
183. ($imported ||= {})["Galv_Character_Effects"] = true
     
184. module Galv_CEffects
     
185.   
     7 f/ X3 V. L# ~1 \
186. #------------------------------------------------------------------------------#  
     6 h2 U+ ?, C* W* w6 U2 W
187. #  SETUP OPTIONS
     6 W5 Z* O9 F( i" M+ i- M. K( U
188. #------------------------------------------------------------------------------#
     ( ]& O! ?, R) y1 A
189.   
     5 {7 m# O  A$ ~( {( P
190.   MIRROR_REGION = 1     # Region ID used to determine mirror walls. Paint the
     # a$ \& F8 b- u( Y4 Q' g" Q" D
191.                         # region on the wall you want to make reflective (and
     
192.                         # then use tiles/mapping that make the parallax visible)
     2 ~  G8 e! L! o3 n5 J4 _
193.   
     - w$ i, c3 @( @+ p, B7 P8 q
194.   ICON_OFFSET = -60     # Y offset for icons that are displayed above characters
     
195.    
     
196.   REFLECT_Z = -10       # Z level of reflections
     
197.   SHADOW_Z = 0          # Z level of shadows
     5 k. n/ l/ ^" J: S  s
198.   
     # C8 p& V& o" l3 S$ P
199. #------------------------------------------------------------------------------#  
     
200. #  END SETUP OPTIONS
     
201. #------------------------------------------------------------------------------#
     " Z5 j. J  y9 c
202. end
     8 T  @: m- Y4 ~) z! P; u" b  i& T  @
203.   
     8 F( j+ Z: r: T
204.   
     7 w# U5 z+ Y$ n4 p# n- L. G
205. 
     8 u0 r2 T1 R+ x. {- O8 M) d2 w
206. 
     9 d/ {- p- E# x0 X( Q% j6 U' j/ i
207. class Game_Map
     8 ?/ Z# m, P+ J0 t% A7 V( N6 Y
208.   def do_icons(refresh = true)
     0 }6 [* V0 h6 W4 F8 y# \
209.     @events.values.each { |e|
     ) V. v/ t( c; K" b; X9 W% {
210.       next if !e.list
     0 h+ E% m3 v# a$ D* _5 i
211.       if e.list[0].code == 108 && e.list[0].parameters[0] =~ /<icon:(.*),(.*),(.*)>/
     ' |( e4 N& r" Q/ J* [3 K
212.         e.icon = $1.to_i
     
213.         e.icon_offset = [$2.to_i,$3.to_i]
     
214.       else
     
215.         e.icon = 0
     8 w  g3 p( b. T
216.         e.icon_offset = [0,0]
     & Q9 R" C) Z  \; R6 o/ v* f
217.       end
     
218.     }
     & q/ k' ^+ O; i$ y$ }
219.     SceneManager.scene.spriteset.refresh_effects if refresh
     
220.   end
     
221.    
     
222.    
     0 X: V! g* V/ A- V- L7 w% D
223.   def do_shadows(refresh = true)
     ! H5 z9 j1 C" H2 A5 M$ g
224.     @events.values.each { |e|
     
225.       next if !e.list
     , `& b4 _7 [" u2 j
226.       if e.list[0].code == 108 && e.list[0].parameters[0] =~ /<shadow>/
     8 Z/ r, V* o1 \! ?, K
227.         e.shadow = true
     
228.       else
     . c4 p* w% D9 a7 y" K
229.         e.shadow = false
     
230.       end
     % t8 f# i( M, h
231.     }
     
232.     SceneManager.scene.spriteset.refresh_effects if refresh
     
233.   end
     : v/ F1 P* S# |4 q0 i- D
234.    
     6 f/ N$ }8 s8 o3 i4 C
235.   def do_reflects(refresh = true)
     
236.     @events.values.each { |e|
     
237.       next if !e.list
     
238.       if e.list[0].code == 108 && e.list[0].parameters[0] =~ /<reflect>/
     
239.         e.reflect = true
     
240.       else
     
241.         e.reflect = false
     
242.       end
     
243.     }
     % j! s1 G1 h3 z3 C
244.     SceneManager.scene.spriteset.refresh_effects if refresh
     
245.   end
     ' t2 y( p! V2 e1 G
246.    
     # M6 B5 E1 v* x$ L0 a
247.   def do_all_chareffects
     
248.     do_icons(false)
     
249.     do_shadows(false)
     
250.     do_reflects(false)
     - |7 f' O3 ?& F; k7 Q- m' Y
251.   end
       P  M! N& t- J* g/ H
252.    
     
253. end # Game_Map
     
254. 
     
255. 
     
256. 
     
257.   
     * R1 U1 Q8 B: J* s- P5 v2 P9 N1 K
258. class Game_Interpreter
     
259.    
     
260.   def remove_icon
     
261.     icon(@event_id,0)
     4 ~" V2 ~3 L& z4 G" l: D" Y
262.   end
     2 _* G; N2 L3 C
263.   
     / o7 M# R: {( U1 A$ e- _6 O5 _
264. #-----------------------------------#
     
265. #  REFLECTIONS
     
266. #-----------------------------------#
     
267.   
     
268.   # Add/Remove Reflections from selected events
     % g' I7 l2 ^! R  Y- _0 q) j
269.   def reflect(*args,status)
     . c% n. u1 D5 S: U: v5 x
270.     char_ids = [*args]
     + N* K, e6 [' M( G- Z+ t; L
271.     if char_ids == [:all]
     / E' e5 z) r3 m  _) A+ B
272.       $game_map.events.values.each { |e| e.reflect = status }
     
273.     else
     ! o5 k+ S) r3 M
274.       char_ids.each {|c| $game_map.events[c].reflect = status }
     
275.     end
     
276.     SceneManager.scene.spriteset.refresh_effects
     
277.   end
     
278.    
     * E4 z& C! w; |1 q& j3 o
279.   # Change forever actor's reflect status
     2 d$ Q) F2 j2 Z( a: Y; C, J
280.   def actor_reflect(actor_id,status)
     
281.     $game_actors[actor_id].reflect = status
     
282.     $game_player.refresh
     
283.   end
     ( {* F  k/ l9 g. S
284.    
     * ^; t$ A$ l# x1 U  l. P
285.   # Change forever vehicle's reflect status
     
286.   def v_reflect(*args,status)
     
287.     char_ids = [*args]
     
288.     if char_ids == [:all]
     
289.       $game_map.vehicles.each { |v| v.reflect = status }
     
290.     else
     
291.       char_ids.each { |v| $game_map.vehicles[v].reflect = status }
     1 T8 h) U4 ?: ?: I8 L$ d
292.     end
     
293.     SceneManager.scene.spriteset.refresh_effects
     9 q0 G7 V& v3 q# ~5 Z
294.   end
     / D: }. F7 w( g/ U
295.   
       d7 {7 s/ S8 |6 Q& \
296.   def reflect_options(*args)
     
297.     $game_map.reflect_options = [*args]
     0 n9 b; x# g6 O+ N0 j7 L
298.     SceneManager.scene.spriteset.refresh_effects
     
299.   end
     : C8 U! ?8 m' f$ i3 I
300.    
     
301.   # Actor reflect sprite change
     & o9 T5 Y; E7 G, M( m3 ]: C. @
302.   def reflect_sprite(actor_id,filename,pos)
     
303.     $game_actors[actor_id].reflect_sprite = [filename,pos]
     
304.     $game_player.refresh
     5 y2 X5 _& a8 u- w  G1 `! `
305.   end
     
306.    
     
307.   # Event reflect sprite change
     . I* }0 m: N9 _; u. P4 [4 w
308.   def reflect_esprite(event_id,filename,pos)
     
309.     $game_map.events[event_id].reflect_sprite = [filename,pos]
     . A9 z) u) g# ~, T
310.     $game_map.events[event_id].reflect = true
     
311.     SceneManager.scene.spriteset.refresh_characters
     
312.   end
     . n: x% F* }5 e- b" _) D# G. n& I; h
313.    
     - i" Y( Z2 O' Q1 u4 [/ H7 N6 t
314.   # Vehicle reflect sprite change
     
315.   def reflect_vsprite(v_id,filename,pos)
     ! a  @! G; O* U  W% D0 C3 r: Q
316.     $game_map.vehicles[v_id].reflect_sprite = [filename,pos]
     
317.     SceneManager.scene.spriteset.refresh_characters
     2 i% T3 y; {, s% s
318.   end
     : Z1 [  u! |8 r
319.   
     " D0 o, Z& |3 o/ u: T5 \; |" R
320. #-----------------------------------#
     + n+ p5 n9 I% A7 S. f$ F; `1 T  u
321. #  SHADOWS
     
322. #-----------------------------------#
     
323.   
     
324.   # Add/Remove Shadows from selected characters
     
325.   def shadow(*args,status)
     2 Y  ]; C* A6 P
326.     char_ids = [*args]
     # p9 [# `7 w. D/ W- j, O
327.     if char_ids == [:all]
     
328.       $game_map.events.values.each { |e| e.shadow = status }
     
329.     else
     
330.       char_ids.each {|c| $game_map.events[c].shadow = status }
     8 n4 P0 V3 O4 ^2 y/ ~" S4 v
331.     end
       x4 P5 r- U/ a4 c
332.     SceneManager.scene.spriteset.refresh_effects
     
333.   end
     7 W$ c/ P; ]* v- u$ k5 W
334.    
     * r3 z3 P) u9 V& [
335.   # Change player and follower shadows
     
336.   def actor_shadows(status)
     + K8 \$ D* |3 X' ^8 I
337.     $game_player.shadow = status
     
338.     $game_player.followers.each { |f| f.shadow = status }
     # K1 V, q% Z: ~7 d/ T2 h
339.     SceneManager.scene.spriteset.refresh_effects
     * }' n+ m& J  K" k; v
340.   end
     
341.    
     
342.   # Change vehicle's shadow status
     # t1 m" k9 @! W: \3 z
343.   def v_shadow(*args,status)
     
344.     char_ids = [*args]
     
345.     if char_ids == [:all]
     . c6 y/ U# h. z8 C4 e0 T
346.       $game_map.vehicles.each { |v| v.shadow = status }
     ' z  b$ K0 |# p5 l  c. ^3 ]: D: @. f4 M
347.     else
     
348.       char_ids.each { |v| $game_map.vehicles[v].shadow = status }
     
349.     end
     
350.     SceneManager.scene.spriteset.refresh_effects
     1 C3 w4 v& r/ t% y5 P
351.   end
     
352.    
     3 Z2 ^2 B/ C7 U# M7 V* ^, ^
353.   def shadow_options(*args)
     
354.     $game_map.shadow_options = [*args]
     
355.     SceneManager.scene.spriteset.refresh_effects
       W, V  O9 f; l. B- b6 @
356.   end
     + x* \! V  j; ^! S- J1 y1 Z, q7 a
357.   
     ' h4 L9 ~/ o3 O
358.   def shadow_source(*args,shad_id)
     2 M% P/ P' @  _. }- i
359.     shadsource = [*args]
     $ a  r% N+ F/ ^3 w  N) p6 h
360.   
     
361.     if shadsource.count == 1
     
362.       $game_map.light_source[shad_id] = [$game_map.events[shadsource[0]].real_x,
       m7 R# \! V) c- c. W& F& P5 _6 A
363.         $game_map.events[shadsource[0]].real_y]
     / c- a* v* ~( \& H- R7 j
364.     elsif shadsource.count > 1
     $ p4 k1 ~* }: _
365.       $game_map.light_source[shad_id] = shadsource
     
366.     else
     
367.       $game_map.light_source = []
     
368.     end
     
369.   end
     
370.   
     9 d" h2 o+ y5 i- k) b
371.   
     7 u. D+ q& ?9 d- u/ e8 s3 Q
372. #-----------------------------------#
     ' d+ i7 P, [* l* ^* r  E1 V* i
373. #  ICONS
     7 H$ x, }! w: p" N. ?; k, e
374. #-----------------------------------#
     
375.   
     , j# W" F) E, }. h: x# h1 M
376.   # Add/Remove Icons from selected events
     
377.   def icon(*args,icon_id)
     
378.     char_ids = [*args]
     4 S7 T; A/ i2 n& L& Q7 _
379.     if char_ids == [:all]
     & G8 c8 [1 ~6 x: \
380.       $game_map.events.values.each { |e|
     
381.       if e.icon <= 0
     
382.         e.icon = nil
     & s6 ?( g" P2 s0 b. A) V) p' [8 N
383.       else
     
384.         e.icon = icon_id
     
385.       end
     - N' E/ p* ?, B; f8 A7 k
386.     }
     
387.     else
     & Y+ e  K# L4 ^- s+ z# n
388.       char_ids.each {|c| $game_map.events[c].icon = icon_id }
     
389.     end
     4 J. _; ^+ s* }! U& W$ a
390.     SceneManager.scene.spriteset.refresh_effects
     
391.   end
     8 @! Z: S# U3 o/ X0 ?9 b
392.    
     
393.   # Change forever actor's icon
     " p7 K* l: }: G0 g+ g& {
394.   def actor_icon(actor_id,icon_id)
     ' @! |' ?2 c' u9 Z
395.     $game_actors[actor_id].icon = icon_id
     
396.     $game_player.refresh
     
397.   end
     
398.    
     
399.   # Change forever vehicle's icon
     
400.   def v_icon(*args,icon_id)
     / L# \% N: g( t4 k
401.     char_ids = [*args]
     
402.     if char_ids == [:all]
     - @6 G8 q. X  y! z. d
403.       $game_map.vehicles.each { |v| v.icon = icon_id }
     
404.     else
     7 x  x, }4 w' u- }
405.       char_ids.each { |v| $game_map.vehicles[v].icon = icon_id }
     9 f! r, G! ?/ P6 p" Q7 P
406.     end
     
407.     SceneManager.scene.spriteset.refresh_effects
     
408.   end
     
409.   
     
410. #-----------------------------------#
       A& U' N$ b: O
411. #  GENERAL
     / D8 ?/ V  p: ~0 t4 s4 L0 c
412. #-----------------------------------#
     6 a  O6 I3 _6 e4 H+ R( D4 V& s. S( M
413.   
     
414.   # Turn on/off effects
     % Q, U3 G. L/ X% X. B) T- w
415.     # 0 = reflect
     , `2 r4 H8 f; D  e  U' }
416.     # 1 = shadow
     
417.     # 2 = mirror
     : B: _  x" a& K- A; M$ e1 G1 j! ]- q2 I* M
418.     # 3 = icon
     
419.       
     5 }  t5 c# V- p
420.   def char_effects(*args,status)
     
421.     [*args].each { |e| $game_map.char_effects[e] = status }
     
422.     SceneManager.scene.spriteset.refresh_effects
     & U( m2 k% v, S. g! s6 `
423.   end
     
424.   
     
425.    
     ' c7 }/ q: D$ N1 j  ^
426. end # Game_Interpreter
     & x" p2 c' K) [0 R& B1 R
427.   
     1 `9 h! B) ]" h+ X. i& ?
428.   
     & x* N. u- \/ a
429. #-------------------------------------------------------------------------------
     - ^" b6 u3 h" W( N$ D5 c. F
430. #  Spriteset_Map
     ' n, l3 H$ ^- o
431. #-------------------------------------------------------------------------------
     , a" ~% `+ c8 S, J
432.   
     + I( ^8 ~' h% N; Y; t7 ^  D
433. class Spriteset_Map
     ' n% k2 D. [9 B) w% e5 w; d1 Z& D
434.   alias galv_reflect_sm_initialize initialize
     , H+ `* h8 C( d0 h, u" S- P
435.   def initialize
     
436.     create_effects
     8 g3 h! |- N- R9 u5 n9 S* @
437.     galv_reflect_sm_initialize
     7 e) W) Q1 a( y. E; ^( S. f
438.     refresh_characters
     " o$ y- i+ r; B3 E$ [
439.   end
     . V5 B* P* P" U8 _1 m5 a! _
440.    
     
441.   alias galv_reflect_sm_refresh_characters refresh_characters
     
442.   def refresh_characters
     
443.     galv_reflect_sm_refresh_characters
     
444.     create_effects
     
445.   end
     
446.    
     ( L4 v8 S( F# a- c2 N$ i
447.   def refresh_effects
     7 v. h9 \9 u4 ^& r+ R
448.     dispose_effects
     
449.     create_effects
     / y" C1 W: I& ^# g/ B- T
450.   end
     
451.    
     : X1 N- b, E. K9 G, b0 u
452.   def create_effects
     
453.     @shadow_sprites = []
     
454.     @reflect_sprites = []
     # c& N. v' Z% W/ C4 U4 D
455.     @mirror_sprites = []
     
456.     @icon_sprites = []
     . a- Q, b7 f; Q& e( `" n
457.       
     4 b3 a5 O/ n% J( ?4 i  O& D
458.     # Do reflections
     1 u# q7 o! \1 m- v! s: h
459.     if $game_map.char_effects[0]
     
460.       $game_map.events.values.each { |e|
     ) Q8 n& K' ~0 t- W1 h& C
461.         @reflect_sprites.push(Sprite_Reflect.new(@viewport1, e)) if e.reflect
     
462.       }
     + d8 W1 `& n8 E& J
463.       $game_player.followers.each { |f|
     
464.         @reflect_sprites.push(Sprite_Reflect.new(@viewport1, f)) if f.reflect
     1 Y  S/ l+ x+ |$ K
465.       }
     
466.       if $game_player.reflect
     
467.         @reflect_sprites.push(Sprite_Reflect.new(@viewport1, $game_player))
     
468.       end
     
469.       $game_map.vehicles.each { |v|
     6 G8 ]# B  `% n6 |# A
470.         @reflect_sprites.push(Sprite_Reflect.new(@viewport1, v)) if v.reflect
     * j3 r1 N; s* X% Z& z
471.       }
     
472.     end
     . \6 w1 n2 z% P* n; _* G. {4 i. M
473.       
     - p9 F1 n/ a% U; l9 t4 p+ j! u
474.     # Do mirrors
     
475.     if $game_map.char_effects[2]
     
476.       $game_map.events.values.each { |e|
     
477.         @mirror_sprites.push(Sprite_Mirror.new(@viewport1, e)) if e.reflect
     
478.       }
     
479.       $game_player.followers.each { |f|
     , X1 d  C, R+ J  {
480.         @mirror_sprites.push(Sprite_Mirror.new(@viewport1, f)) if f.reflect
     " y5 J3 M: i# Z$ R: K* g) P% d! d
481.       }
     2 ~8 U: r% a- L0 Q5 N  N2 x  X
482.       if $game_player.reflect
     ; N$ [7 z( F/ D( {# O1 `: D
483.         @mirror_sprites.push(Sprite_Mirror.new(@viewport1, $game_player))
     - e3 A' W2 K  F1 m
484.       end
     
485.       $game_map.vehicles.each { |v|
     # l) r9 h6 D" \$ `+ Z% M9 n- e6 Y, {
486.         @mirror_sprites.push(Sprite_Mirror.new(@viewport1, v)) if v.reflect
     / c$ {7 J2 X" \0 G9 a  f) A
487.       }
     2 y. ?: j0 N& H* S7 b& v9 f
488.     end
     
489.       
     
490.     # Do Shadows
     % M0 N" ~- _7 s  i5 r0 J9 Q
491.     if $game_map.char_effects[1]
     % X: `% n) e, E% j" H5 @4 f+ w
492.       return if $game_map.light_source.empty?
     " I0 i" o7 a8 E# ]* g  `
493.       $game_map.light_source.count.times { |s|
     0 ?. x4 \) f# i% a9 l
494.         $game_map.events.values.each { |e|
     6 [9 V* ~# Z  N
495.           @shadow_sprites.push(Sprite_Shadow.new(@viewport1, e, s)) if e.shadow
     
496.         }
     9 H5 K- S# d3 g1 T3 B2 R
497.         $game_player.followers.each { |f|
     
498.           @shadow_sprites.push(Sprite_Shadow.new(@viewport1, f, s)) if f.shadow
     ! Z' I' {: X) p" M" K
499.         }
     $ V- s( `! f3 t4 c3 Z) x0 O3 E5 Z
500.         if $game_player.shadow
     
501.           @shadow_sprites.push(Sprite_Shadow.new(@viewport1, $game_player, s))
       j5 f: Z- U# M/ p2 Q" m. }7 v& N9 n7 e
502.         end
     
503.         $game_map.vehicles.each { |v|
     / B* M4 y$ f; \( W$ I8 G% f* c( [
504.           @shadow_sprites.push(Sprite_Shadow.new(@viewport1, v, s)) if v.shadow
     6 {& x6 A( C& T
505.         }
     
506.       }
     * L, K% u3 C) c7 y5 A
507.     end
     
508.       
     
509.     # Do icons
     4 X- W3 P& f6 t' W! Z% w
510.     if $game_map.char_effects[3]
     1 @) X' i2 r+ U$ ~$ V3 H
511.       $game_map.events.values.each { |e|
     2 p( K1 j4 L7 X9 p- d
512.         @icon_sprites.push(Sprite_Icon.new(@viewport1, e)) if e.icon
     
513.       }
     
514.       $game_player.followers.each { |f|
     
515.         @icon_sprites.push(Sprite_Icon.new(@viewport1, f)) if f.icon
     
516.       }
     
517.       if $game_player.icon
     
518.         @icon_sprites.push(Sprite_Icon.new(@viewport1, $game_player))
     7 @5 m, G+ r0 A! p  a
519.       end
     4 V/ K$ ]2 X9 J; l8 d5 O
520.       $game_map.vehicles.each { |v|
     - ?% U0 A+ Z" s4 q" [) i
521.         @icon_sprites.push(Sprite_Icon.new(@viewport1, v)) if v.icon
     ! s8 F" w4 w$ ^
522.       }
     ! Q! H$ n- Y0 Z0 e. S& w* B, e
523.     end
     % Q1 A* r5 \- s+ M/ E; K
524.   end
     0 P3 s3 B! \: _: Y" q" z
525.    
     
526.   alias galv_reflect_sm_update update
     9 _) J" E0 R( {
527.   def update
     
528.     galv_reflect_sm_update
       `1 R# u" ~, T! ?) f2 i0 H5 h
529.     @reflect_sprites.each {|s| s.update} if $game_map.char_effects[0]
     / y8 T! ~0 G' a- C* @( O
530.     @mirror_sprites.each {|s| s.update} if $game_map.char_effects[2]
     ; U& K! ~2 B3 A- I" x. K/ q# q
531.     @shadow_sprites.each {|s| s.update} if $game_map.char_effects[1]
     $ G' D( J! D+ U, q" d* Y( ^5 Z; g
532.     @icon_sprites.each {|s| s.update} if $game_map.char_effects[3]
     + G0 p5 K+ |2 b* K4 W* \
533.   end
     
534.   
     
535.   alias galv_reflect_sm_dispose_characters dispose_characters
     ) d. y1 l+ a; Q! q8 O& i
536.   def dispose_characters
     2 W7 n4 G# R% X8 g( r
537.     galv_reflect_sm_dispose_characters
     % i, H+ @/ [# h
538.     dispose_effects
     + P3 T- U1 X( Y
539.   end
     ! Y4 O- F, y8 r' C6 E( i/ ]
540.    
     ) z4 P8 d( w. N( p0 z+ u
541.   def dispose_effects
     ( J% ~6 b. d' l7 z/ F( U
542.     @reflect_sprites.each {|s| s.dispose}
     
543.     @shadow_sprites.each {|s| s.dispose}
     & h* V8 J* V. x5 L+ g
544.     @mirror_sprites.each {|s| s.dispose}
     
545.     @icon_sprites.each {|s| s.dispose}
     
546.   end
     3 R) [0 }( \2 g( P) T" R" \2 {, j" R
547. end # Spriteset_Map
     
548.   
     
549.   
     6 d- t+ _( y$ f% A6 S
550. #-------------------------------------------------------------------------------
     
551. #  Sprite_Reflect
     $ W$ n% }: j: p4 r
552. #-------------------------------------------------------------------------------
     
553.   
     
554. class Sprite_Reflect < Sprite_Character
     & Q4 A$ b( e, L7 G  o
555.   def initialize(viewport, character = nil)
     - t! z2 v1 \, Q, t# R3 z. m
556.     super(viewport, character)
     
557.   end
     
558.   
     
559.   def update
     / ~9 o3 I# o! V$ g/ `. @1 E
560.     super
     6 q9 T7 t' d3 M2 W
561.   end
     6 B' V9 V# B" x! _; D- A
562.    
     
563.   def update_balloon; end
     
564.   def setup_new_effect; end
     4 c0 W; Y* H/ }; R! o0 W, Q! l
565.    
     ) p0 J5 o7 ?0 E) Q( K0 v
566.   def set_character_bitmap
       ~$ f# `6 V1 }6 A# ^
567.     if @character.reflect_sprite
     
568.       self.bitmap = Cache.character(@character.reflect_sprite[0])
     1 R7 X: ]. ?; b! Q
569.     else
     
570.       self.bitmap = Cache.character(@character_name)
     % _5 \* X0 y9 X; F6 _0 i
571.     end
     
572.     self.mirror = true
     % o0 ?) f+ e" g' b8 k! p. ]
573.     self.angle = 180
     
574.     self.opacity = 220
     , P& W2 z2 c$ V" M0 k' s& c- d7 w
575.     self.z = Galv_CEffects::REFLECT_Z
     
576.     self.wave_amp = $game_map.reflect_options[0]
     
577.       
     
578.     sign = @character_name[/^[\!\$]./]
     
579.     if sign && sign.include?(')
     * h8 r8 @% A  G/ I9 I
580.       @cw = bitmap.width / 3
     1 H3 L- p: y8 }# t# H
581.       @ch = bitmap.height / 4
     
582.     else
     
583.       @cw = bitmap.width / 12
     # j4 r+ z8 U! x: s) |. @
584.       @ch = bitmap.height / 8
     
585.     end
     4 G( k& t1 A8 a
586.     self.ox = @cw / 2
     
587.     self.oy = @ch
     
588.   end
     
589.   
     2 X: i( N) W3 a. {( ?0 P# E
590.   def update_position
     
591.     self.x = @character.screen_x
       W, C0 P2 [8 |2 M$ p% u
592.     jump = @character.jumping? ? @character.jump_height * 2 : 0
     
593.     alt = @character.altitude ? @character.altitude * 2 : 0
     # U" w# a8 E* _6 s
594.     self.y = @character.screen_y - 3 + jump + alt
     / Q) t! j0 _; [
595.   end
     
596.   
     2 K" H( F8 ~9 a1 O, v
597.   def update_other
     : {7 v7 f+ K! Y
598.     self.blend_type = @character.blend_type
     
599.     self.visible = !@character.transparent
     
600.   end
     3 u7 w3 u, e* w2 i9 n- V1 R% ^% O
601.    
     6 v# Q0 [) [+ I7 e$ m" w
602.   def update_src_rect
     
603.     if @character.reflect_sprite
     
604.       index = @character.reflect_sprite[1]
     
605.     else
       \+ l/ G1 A: t9 ^
606.       index = @character.character_index
     
607.     end
     $ r( @8 [( G& D6 P$ ?
608.     pattern = @character.pattern < 3 ? @character.pattern : 1
     & [$ B# c- z6 n3 |  t5 d6 N  s
609.     sx = (index % 4 * 3 + pattern) * @cw
     ) a9 @( |6 s+ K1 t: B
610.     sy = (index / 4 * 4 + (@character.direction - 2) / 2) * @ch
     
611.     self.src_rect.set(sx, sy, @cw, @ch)
     
612.   end
     + F8 M3 o! Y& c" @- F0 Z& P3 T# z
613. end # Sprite_Reflect < Sprite_Character
     
614.   
     
615.   
     
616. #-------------------------------------------------------------------------------
     ; |$ E  F- S, {" t
617. #  Sprite_Mirror
     
618. #-------------------------------------------------------------------------------
     + X. c% c+ [8 S* @  b  V' i
619.   
     
620. class Sprite_Mirror < Sprite_Character
       ^' F. k: J" J2 S9 Q7 i
621.   def initialize(viewport, character = nil)
     
622.     @distance = 0
     , B0 f  |  V  Q- l
623.     super(viewport, character)
     3 R$ o2 {6 P" p
624.   end
       u7 A, D+ L8 X
625.   
     ) `7 a. O/ s) G, C9 K- V
626.   def update
     & R' C  ]  ^. N2 v
627.     super
     
628.   end
     
629.    
     4 C+ l; N" d5 D; u$ {$ l
630.   def update_balloon; end
     
631.   def setup_new_effect; end
     
632.    
     " o& x+ N8 b* r+ @
633.   def set_character_bitmap
     
634.     if @character.reflect_sprite
     & g$ L# U# F0 n3 x
635.       self.bitmap = Cache.character(@character.reflect_sprite[0])
     
636.     else
     
637.       self.bitmap = Cache.character(@character_name)
     
638.     end
     2 l# R6 x4 z' ?& H2 c; J# o
639.     self.mirror = true
       z5 G& c. W" _8 {( b
640.     self.opacity = 255
     8 W/ X6 I" ~! T- o
641.     self.z = Galv_CEffects::REFLECT_Z
     / t' O8 I1 f' a1 U
642.       
     
643.     sign = @character_name[/^[\!\$]./]
     & t" E5 D- e# R  S' i
644.     if sign && sign.include?(')
     & C; i' s# z0 q  ?  p6 g
645.       @cw = bitmap.width / 3
     
646.       @ch = bitmap.height / 4
     
647.     else
     
648.       @cw = bitmap.width / 12
     * z; Y% ]; K- H
649.       @ch = bitmap.height / 8
     
650.     end
     6 Z% J: e8 t! R
651.     self.ox = @cw / 2
     * u' N1 R- z& I) T3 Z# J
652.     self.oy = @ch
     " A" y" @$ z4 ?1 N0 f
653.   end
     
654.   
     & l1 X/ @% B& x; Y" h
655.   def update_src_rect
     4 ]7 B) h+ C7 ]- F' O8 e, Z
656.     if @character.reflect_sprite
     & g( Y4 Z8 Q& J. \. ^* x
657.       index = @character.reflect_sprite[1]
     7 C. d% b" ~! r/ N* t
658.     else
     
659.       index = @character.character_index
       v- g, e" |! i3 Q5 S& I
660.     end
     # I" s; {% `) _4 q2 o5 X
661.     pattern = @character.pattern < 3 ? @character.pattern : 1
     4 i! S; n. W" [
662.     sx = (index % 4 * 3 + pattern) * @cw
     
663.     sy = (index / 4 * 4 + (10 - @character.direction - 2) / 2) * @ch
     : m8 V: r% d" e; d" f
664.     self.src_rect.set(sx, sy, @cw, @ch)
     5 c* p2 K* t# p
665.   end
     $ @& M' J- G/ s: A8 B1 H. F0 Y
666.    
     : I8 W0 b! G% B
667.   def get_mirror_y
     5 A0 w& }$ ?5 h2 L8 _: \( X7 X
668.     20.times {|i|
     ( T: B' B% ^* F) _% K. e, U
669.       if $game_map.region_id(@character.x, @character.y - i) == Galv_CEffects::MIRROR_REGION
     
670.         @distance = (i - 1) * 0.05
     2 y" {9 R* U9 x: L0 p0 ?. d% h' ]
671.         [url=home.php?mod=space&uid=502659]@DISPLAY[/url] = @character.y - i - $game_map.display_y + $game_map.height
     
672.         self.opacity = 255
     / N. O( v! |6 \7 [! I$ \# y
673.         return (@character.y - i + 1 - $game_map.display_y) * 32 - i * 4
     / f7 @( L5 E4 m  \5 H7 A* F% W
674.       end
     
675.     }
     
676.     self.opacity = 0
     ( N" U# {/ e; Z
677.     return @ch
     
678.   end
     
679.    
     
680.   def update_position
     4 F$ t; s  H8 j: w" J3 [% g) p
681.     self.x = @character.screen_x
     # {0 Q% o$ t8 O/ R7 T
682.     self.y = get_mirror_y - 6
     5 s' j  l! l( J- M: A' e- ]
683.     self.zoom_x = 1 - @distance
     & f& J( b: e( ?: E( `& j7 u
684.     self.zoom_y = 1 - @distance
     % C) H7 H) i! Q/ N1 ^% b
685.   end
     
686.   
     
687.   def update_other
     
688.     self.blend_type = @character.blend_type
     
689.     self.visible = !@character.transparent
     
690.   end
     
691. end # Sprite_Mirror < Sprite_Character
     
692.   
     
693.   
     
694. #-------------------------------------------------------------------------------
     
695. #  Sprite_Shadow
     
696. #-------------------------------------------------------------------------------
     + T; b% q5 n0 O1 B& d
697.   
     ' y. V3 Z+ ]2 d
698. class Sprite_Shadow < Sprite_Character
     
699.   def initialize(viewport, character = nil, source)
     
700.     [url=home.php?mod=space&uid=14094]@flicker[/url] = 0
     $ w. S$ Q" B$ c. k! Z
701.     @famount = 0
     4 S& u% x$ [0 M' I6 l
702.     @aamount = 0
     
703.     [url=home.php?mod=space&uid=171370]@source[/url] = source
     
704.     super(viewport, character)
     
705.   end
     
706.    
     , {" y8 ~, J0 G6 h
707.   def update_balloon; end
     
708.   def setup_new_effect; end
     
709.   
     8 r* o1 f! l" V: [6 |& Y( Q
710.   def update
     
711.     super
     
712.     update_bitmap
     
713.     update_src_rect
     $ [) c7 |: ~" Z6 M. M
714.     update_position
     % q0 B# {. k5 Y9 K- x
715.     update_other
     6 ?" c1 L" o7 a; r
716.     update_facing
     
717.   end
     ( s9 A. s" m2 ^7 u# |/ L/ o
718.    
     . A4 M3 T# j7 X, n" \& `
719.   def set_character_bitmap
     ; s( g/ r! l  [% T4 v& A/ ]
720.     self.bitmap = Cache.character(@character_name)
     % J4 S: e$ o6 [+ X8 `( x! e
721.      
     
722.     self.color = Color.new(0, 0, 0, 255)
     $ s7 i' N7 T$ J* B! o# L+ ~- @
723.     self.z = Galv_CEffects::SHADOW_Z
     ) W+ v. e2 ?, F2 ~" l) e
724.     self.wave_amp = 1 if $game_map.shadow_options[2]
     2 Q( |4 \) V8 e5 ^; ]
725.     self.wave_speed = 1000
     * \7 c+ E- e  W% E! I
726.       
     3 ]( `! G: D* c6 @5 R
727.     sign = @character_name[/^[\!\$]./]
     ) S0 r; R. q1 r9 C9 O
728.     if sign && sign.include?(')
     
729.       @cw = bitmap.width / 3
     2 R2 h+ c( s# n1 n
730.       @ch = bitmap.height / 4
     
731.     else
     . ^* a/ G$ S" O9 C  B2 X; t; m
732.       @cw = bitmap.width / 12
     $ D" c2 [2 ~4 `# R0 Z( o8 @( O
733.       @ch = bitmap.height / 8
     ! {8 n) O2 V7 T' `" d, Y# g
734.     end
     
735.     self.ox = @cw / 2
       @4 S  k/ T, S! ~# y* t& G  H
736.     self.oy = @ch
     " ~9 P; q9 [1 h) {4 |% r
737.   end
     9 d: R  L9 R$ N/ o7 e$ N$ ~
738.   
     
739.   def update_position
     ( C4 E5 l1 H( w; L: X" w
740.     self.x = @character.screen_x
     8 m$ I) R2 q% m* u
741.     self.y = @character.screen_y - 10
     
742.     get_angle
     
743.   end
     / M7 d( l' {6 a% a4 {0 Z& H8 m
744.    
     
745.   def get_angle
     
746.     x = $game_map.light_source[@source][0] - @character.real_x
     
747.     y = $game_map.light_source[@source][1] - @character.real_y
     2 l3 ^2 Y+ a& o$ a3 o
748.     self.opacity = $game_map.shadow_options[0] -
     
749.       Math::sqrt(x * x + y * y) * $game_map.shadow_options[1]
     % [7 D, ?, x$ |: W
750.       
     
751.     if x == 0 && y == 0 || self.opacity <= 0
     
752.       self.opacity = 0
     9 m) ^; p$ u$ R2 E
753.     else
     1 l* I# D4 d$ K  U6 o2 v
754.       self.angle = Math::atan2(x, y) * 180 / Math::PI + @aamount
     ! m: L. }; m, I* B
755.     end
     
756.   end
     9 P9 ^4 u( o! M2 R4 C; J) S
757.    
     
758.   def update_facing
     & r: w9 V) F! u; X( \/ r. V1 G
759.     if @character.y < $game_map.light_source[@source][1]
     : T1 g8 A9 p" H- T, i; U
760.       self.mirror = false
     ' [3 f. _6 m1 G7 {3 E" j0 {% g9 t8 u
761.     else
     
762.       self.mirror = true
     
763.     end
     
764.   end
     
765.    
     $ o' s; M6 n& {0 @
766.   def update_other
     / F1 `. A! b! V& I9 s
767.     self.blend_type = @character.blend_type
     
768.     self.visible = !@character.transparent
     
769.   end
     2 B2 U- J4 y. L8 d& R
770. end # Sprite_Shadow < Sprite_Character
     
771.   
     1 z" N# ^0 g2 G3 ]5 x
772.   
     
773. #-------------------------------------------------------------------------------
     
774. #  Sprite_Icon
     
775. #-------------------------------------------------------------------------------
     ! L4 d0 J" B: i& r, H) ^
776.   
     
777. class Sprite_Icon < Sprite_Character
     5 E- P: H+ o6 k
778.   def initialize(viewport, character = nil)
     
779.     @icon_sprite ||= Sprite.new
     $ \7 w8 ?& ^6 Y: r! u
780.     @icon_sprite.bitmap ||= Cache.system("Iconset")
     
781.     @icon = nil
     ; Y3 ^8 I3 s* ]! r
782.     super(viewport, character)
     * X/ g1 M$ p8 X# e" Z5 `+ d
783.   end
     
784.   
     
785.   def dispose
     
786.     super
     % L. n+ O/ W; M5 _+ ]; u" h, u
787.     if @icon_sprite
     0 u  r) y. Z" P- S5 _+ H
788.       @icon_sprite.dispose
     0 m0 T2 j" n2 ^' ]
789.       @icon_sprite = nil
     
790.     end
     . r% R# M* {+ F& Z. l
791.   end
     
792.    
     2 ?+ n- O7 Q% y
793.   def update
     
794.     super
     
795.     update_icon
     
796.   end
     ; r- [8 `- Z/ r, |
797.    
     2 Z  ?3 ~  E) g; C: X0 }
798.   def update_icon
     
799.     return if !@character.icon
     - _$ `6 o2 g+ Z
800.     draw_icon(@character.icon)
     
801.   end
     7 m( q$ b4 k( Y) c+ p
802.    
     * b8 a' [$ ?) P( X4 ]# ^
803.   def draw_icon(icon_index)
     , r6 J* z+ F) }7 D
804.     return if !@icon.nil?
     
805.     rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
     & v: W& l/ G2 c$ Q
806.     @icon_sprite.src_rect  = rect
     3 d. J9 H- H9 ^/ q  ~* T
807.     @icon = icon_index
     7 W: E8 ~1 K& C3 U
808.   end
     % [- ^% _* u, l/ Y: M( ]; v4 I
809.    
     2 q# R2 c6 R+ g; D2 x
810.   def update_position
     
811.     @icon_sprite.x = @character.screen_x - 12
     
812.     @icon_sprite.y = @character.screen_y + Galv_CEffects::ICON_OFFSET
     
813.   end
     ; ^* Z5 j  I) O3 ]/ @, ^0 ~
814.   
     5 K$ \$ V- I3 ]5 K( h
815.   def update_other
     ( s" X) ]5 t, e7 @
816.     self.blend_type = @character.blend_type
     
817.     @icon_sprite.visible = !@character.transparent
     
818.   end
     
819. end # Sprite_Icon < Sprite_Character
     ! C; Q% C1 B  u& A
820.   
     
821.   
     " W- a# w) `/ T
822. #-------------------------------------------------------------------------------
     
823. #  Other Stuff
     
824. #-------------------------------------------------------------------------------
     
825.   
     
826.   
     5 [, z1 y! I* Y) W5 a
827. class Game_Character < Game_CharacterBase
     ! c2 A9 w3 M9 Z. ?2 Y8 {% N
828.   attr_reader    :altitude
     
829.   attr_accessor  :reflect
     
830.   attr_accessor  :reflect_sprite
     # g- b0 N+ I: l9 n+ h( V
831.   attr_accessor  :shadow
     ! D1 D6 M& a" z, i7 w9 V4 b* }* E
832.   attr_accessor  :icon
     ' }/ B5 f; A' H6 e& G) [: ]
833.   attr_accessor  :icon_offset
     1 s& g# r3 M( x" \2 y
834. end
     * V& s# U& O7 t4 [  W
835.   
     
836.   
     5 e/ a, q0 K) M/ m6 X! |. T
837. class Game_Event < Game_Character
     
838.   alias galv_reflect_ge_initialize initialize
     ' }9 M2 N1 I/ j+ h" S' U
839.   def initialize(map_id, event)
     * @% \) {2 t  Y% Q  i" S/ `1 n$ \
840.     @reflect = false
     
841.     [url=home.php?mod=space&uid=31758]@Shadow[/url] = false
     - M! z: f, |8 |9 I' ]+ Y( q
842.     @icon_offset = [0,0]
     
843.     galv_reflect_ge_initialize(map_id, event)
     8 V. M$ R8 b5 O. z4 I- B
844.   end
     
845. end # Game_Event < Game_Character
     6 Z- J2 g7 L7 D$ u
846.   
     8 U* j  K7 L' y) A2 P+ P
847.   
     ' i! o. s  h6 G& y8 c
848. class Game_Vehicle < Game_Character
     
849.   attr_reader :map_id
     8 Z. h0 U' K# U! ]+ |
850.    
     : U8 X6 R/ T  @; [
851.   alias galv_reflect_gv_initialize initialize
     1 q, f" s( p( d
852.   def initialize(type)
     
853.     @reflect = true
     
854.     @shadow = true
     3 v6 m6 P( w- W! ?% m; @  n
855.     @icon_offset = [0,0]
     2 a+ s; D& P3 Z6 N
856.     galv_reflect_gv_initialize(type)
     5 D8 n' k5 J9 ?: |, x  V$ @! [
857.   end
     8 _3 B3 o3 X1 j& s3 ^* D: m2 K
858. end # Game_Vehicle < Game_Character
     
859.   
     
860.   
     
861. class Game_Follower < Game_Character
     
862.   alias galv_reflect_gf_initialize initialize
     
863.   def initialize(member_index, preceding_character)
     ( A& C5 p# B5 ^' B4 ?
864.     galv_reflect_gf_initialize(member_index, preceding_character)
     
865.     @reflect = true
     + @* u" D/ u# _& e
866.     @shadow = true
     , l& z& _. |' s" s( v$ m
867.   end
     
868.    
     
869.   alias galv_reflect_gf_refresh refresh
     
870.   def refresh
     1 k& A8 g' X: a8 r5 D; k
871.     galv_reflect_gf_refresh
     % c5 a# p( T: y8 N) T3 x) \4 S# M
872.     return if actor.nil?
     
873.     @reflect = actor.reflect
     3 f) b  p& Q: e  m7 _( Z) }$ o0 V% \
874.     @reflect_sprite = actor.reflect_sprite
     4 M; H8 y0 g3 v! J
875.     @icon = actor.icon
     
876.     if SceneManager.scene_is?(Scene_Map)
     $ N9 |) n: \' h& N  l+ L* u0 [
877.       SceneManager.scene.spriteset.refresh_effects
     
878.     end
     9 A% O8 [" c8 ~+ O# `5 S
879.   end
     - c0 |' N( V" m7 {( K: N* ?
880. end # Game_Follower < Game_Character
     ! |! @. D$ f# i4 j- l
881.   
     
882.   
     
883. class Game_Player < Game_Character
     
884.   alias galv_reflect_gp_initialize initialize
     7 Y6 Y1 r5 Z( M7 x+ u7 u
885.   def initialize
     
886.     galv_reflect_gp_initialize
     8 H5 c6 c5 F8 M7 }; @1 t% h2 i
887.     @reflect = true
     
888.     @shadow = true
       c$ X% U% ?: x
889.   end
     
890.    
     ) ?# e0 ~3 ?2 [2 S5 g
891.   alias galv_reflect_gp_refresh refresh
     7 |9 T2 B, H! n: H
892.   def refresh
     5 N# t' N, Y, [. a
893.     galv_reflect_gp_refresh
     ! w- [4 J4 w; t# W
894.     @reflect = actor.reflect
     # l" z8 t$ ~5 M) o8 A: [
895.     @reflect_sprite = actor.reflect_sprite
     ; X7 d$ Q% n6 }
896.     @icon = actor.icon
     , t( ?% o% s8 F
897.     if SceneManager.scene_is?(Scene_Map)
     
898.       SceneManager.scene.spriteset.refresh_effects
     9 M; ?  V  s. p" b0 u) W4 _7 j
899.     end
     ) p" H6 D& m! F% [
900.   end
     
901. end # Game_Player < Game_Character
     
902.   
     , a) b0 ^4 S1 y# d, U0 W5 s
903.   
     
904. class Scene_Map < Scene_Base
     & m( M0 J. J1 Y0 ^* J
905.   attr_accessor :spriteset
     
906. end # Scene_Map
     4 }% R% X6 h3 @4 ^7 p, |+ N
907.   
     
908.   
     
909. class Game_Map
     
910.   attr_accessor :char_effects
     & P! Z3 r; S! A5 b
911.   attr_accessor :light_source
     ! S8 T) w$ Z% _
912.   attr_accessor :shadow_options
     
913.   attr_accessor :reflect_options
     : Q; |- d# W6 Z9 w& e, C3 I
914.    
     * M& ^- p- L* j5 M; |
915.   alias galv_reflect_game_map_initialize initialize
     
916.   def initialize
     
917.     @light_source = []
     
918.     @shadow_options = [80,10,false]
     / v. v# X7 H  c7 N
919.     @reflect_options = [0]
     
920.     @char_effects = [false,false,false,false]
     
921.     #[reflect,shadow,mirror,icon]
     
922.     galv_reflect_game_map_initialize
     . d# Q) v4 ~2 u1 M6 n, J
923.   end
     
924.    
     
925.    
     + I+ r% D, t+ P
926.   alias galv_reflect_game_map_setup setup
     8 g9 x9 m/ y4 o6 L' U$ t
927.   def setup(map_id)
     ( d. o, U9 b  M" P
928.     galv_reflect_game_map_setup(map_id)
     & K6 J0 K6 S1 |, L& b1 ?5 @
929.     reset_char_effects
     
930.     do_all_chareffects
     4 }3 x3 C2 }( N5 E; X9 ^
931.     if SceneManager.scene_is?(Scene_Map)
     5 s9 {( w) H, u+ ~. k
932.       SceneManager.scene.spriteset.refresh_effects
     1 W2 n) [% ^* U: Z! S7 U8 g( z0 a3 @
933.     end
     ! Z9 O) d# D: h& V) x  `5 ?
934.   end
     
935.    
     
936.   def reset_char_effects
     8 S$ n5 C2 K4 l2 m
937.     @light_source = []
     
938.     @events.values.each { |e|
     4 O& m% R/ r/ Z1 H. R( I
939.       e.reflect = false
     
940.       e.icon = nil }
     
941.   end
     
942. end # Game_Map
     . Y/ j4 P, U* I5 Z0 G# i1 w/ p
943.   
     0 G- S9 U1 @( a; [1 k- U
944.   
     
945. class Game_Actor < Game_Battler
     . J# a6 n  z- m5 P8 \% R2 e
946.   attr_accessor :reflect
     / O2 W" h' ^" }2 r
947.   attr_accessor :reflect_sprite
     ! L) \4 e7 w9 p% A6 }; }: ?% i
948.   attr_accessor :icon
     # m8 _+ \- ]( c
949.    
     
950.   alias galv_reflect_game_actor_initialize initialize
     : ?8 {9 n$ R" o% G$ U  B3 {
951.   def initialize(actor_id)
     
952.     galv_reflect_game_actor_initialize(actor_id)
     1 n2 Q- q2 Q9 Q- E
953.     @reflect = $data_actors[actor_id].reflect
     
954.     @reflect_sprite = $data_actors[actor_id].reflect_sprite
     2 h- B: A+ n2 S% L
955.     @icon_offset = [0,0]
     
956.   end
     6 Q5 n1 u/ N1 O- U% }
957. end # Game_Actor < Game_Battler
     8 g7 m9 R" c. b2 U& b6 F/ J, T0 `& u
958.   
     & k5 X0 e4 A: H6 h
959.   
     
960. class RPG::Actor
     
961.   def reflect_sprite
     
962.     if @reflect_sprite.nil?
     # C% V0 s% _, q: m
963.       if @note =~ /<reflect_sprite:[ ](.*),(.*)>/i
     ) s" A& q$ `# N' Y0 I
964.         @reflect_sprite = [$1.to_s,$2.to_i]
     5 W5 r- X/ ]4 O$ N% e3 x0 G& @9 g
965.       else
     ) T8 x7 Y" F% C  C' Z/ R
966.         @reflect_sprite = nil
     
967.       end
     
968.     end
     4 I0 D1 {( P; X+ P6 N; `
969.     @reflect_sprite
     2 n3 G5 X6 K( J0 O0 I
970.   end
     
971.   def reflect
     
972.     if @reflect.nil?
     
973.       if @note =~ /<no_reflect>/i
     
974.         @reflect = false
     ; S" p. ]( C/ O, q" U
975.       else
     9 c* ]/ I8 r) F% z- n2 |
976.         @reflect = true
     $ Z  x" R. P/ M, G  R* h5 v
977.       end
     & b) A% Q. L9 s# t  J
978.     end
     ( e+ t& {; o) p% [
979.     @reflect
     
980.   end
     
981. end # RPG::Actor
     

复制代码

禺谷皓月

记得口袋妖怪的池塘是有倒影的