水面动态倒影，求解

禺谷皓月

代码复制

6 i. _/ ^3 ^" y3 A; s' j) {& s6 E2 v这个代码怎么用啊，有大神知道吗。我从国外找的。
+ k% u) U1 s8 nhttp://galvs-scripts.com/2013/02/21/character-effects/
是关于动态倒影的

禺谷皓月

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

复制代码

禺谷皓月

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