第二版 月光传说4(冒险岛)宠部分资料(视频)

冰鸷殛霰

宠物系统终于给饿做出来了!================================
凉快一哈=================={/cy}{/cy}


这里是自己做的视频(第一次,请见谅)
地址http://www.tudou.com/programs/view/10uqLVIEIFw/


宠物的基本操作
Q跟随/固定
W攻击
E切换攻击动作

意思就是说,按一次Q后,会从跟随变成固定,就像视频中的一样,BB就站那不动了.再按一次就自己跑过来了...
主角与BB的Y坐标不一致时,BB会自动瞬间移动到主角身边的
按一次W呢就会执行攻击动作了.
当然.BB打了怪,怪就会追BB而不追你了..


带BB的测试版本在下个星期18日放出(wrong!)
第一章将在最近几个星期放出!

更多的系统请期待一一揭晓-0-
游戏的正式版在暑假应该能出了(在暑假才开始做-0-)

游戏的其他资料
http://rpg.blue/viewthread.php?tid=78696&ntime=2008%2D3%2D9+18%3A02%3A00
测试版的下载地址(bug 多)
http://rpg.blue/viewthread.php?tid=73273&ntime=2008%2D3%2D9+18%3A02%3A00

冰鸷殛霰

以下引用rongqingmei于2008-3-16 13:14:50的发言：

看了录象  真的好佩服你  可是也有许多美中不足的地方  像跳跃时屏幕一震一震的 我推荐个脚本 #==============================================================================
# ** Smooth_Scrolling
#------------------------------------------------------------------------------
#  Script by Toby Zerner
#  Gives scrolling a 'smooth' effect (deceleration).
#==============================================================================

class Game_Map
  attr_accessor :deceleration_start
  attr_accessor :deceleration_speed
  #--------------------------------------------------------------------------
  # * Setup
  #     map_id : map ID
  #--------------------------------------------------------------------------
  alias ss_setup setup
  def setup(map_id)
   
    # -- CONFIGURATION VARIABLES
    # When to start decelerating (bigger numbers mean ealier on) [default: 4]
    @deceleration_start = 13
    # How fast to decelerate (bigger numbers mean quicker) [default: 4]
    @deceleration_speed = 13
    # -- END CONFIGURATION VARIABLES
   
    # Call the old setup method
    ss_setup(map_id)
    # Initialize smooth scrolling variables
    # scroll_remain: the number of pixels * 4 the still need to be scrolled
    @scroll_remain_x = 0
    @scroll_remain_y = 0
    # scroll_take: the number of pixels * 4 that are being scrolled every frame
    #   i.e. scrolling speed
    @scroll_take_x = 0
    @scroll_take_y = 0
    # scroll_decel: variables for calculating decelaration
    @scroll_decel_x = 0
    @scroll_decel_y = 0
  end
  #--------------------------------------------------------------------------
  # * Scroll Down
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_down(distance)
    # Ceil the distance
    distance = distance.ceil
    # If the map is scrolling from an event command, then use that scroll speed
    if scrolling? then @scroll_take_y = 2 ** @scroll_speed
    # If the map is not scrolling
    else
      # Make sure the distance is always divisible by 4
      if distance.ceil % 4 == 0 then @scroll_take_y = distance.ceil
      elsif distance.ceil % 4 <= 2 then @scroll_take_y = distance.ceil - distance.ceil % 4
      else @scroll_take_y = distance.ceil + (4 - (distance.ceil % 4)) end
    end
    # If scrolling coordinates are inside the map's boundaries
    unless @display_y + @scroll_remain_y + distance > (self.height - 20) * 128
      # Add onto the amount left to be scrolled
      @scroll_remain_y += distance
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Left
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_left(distance)
    # Ceil the distance
    distance = distance.ceil
    # If the map is scrolling from an event command, then use that scroll speed
    if scrolling? then @scroll_take_x = 2 ** @scroll_speed
    # If the map is not scrolling
    else
      # Make sure the distance is always divisible by 4
      if distance.ceil % 4 == 0 then @scroll_take_x = distance.ceil
      elsif distance.ceil % 4 <= 2 then @scroll_take_x = distance.ceil - distance.ceil % 4
      else @scroll_take_x = distance.ceil + (4 - (distance.ceil % 4)) end
    end
    # If scrolling coordinates are inside the map's boundaries
    unless @display_x - @scroll_remain_x - distance < 0
      # Add onto the amount left to be scrolled
      @scroll_remain_x -= distance
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Right
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_right(distance)
    # Ceil the distance
    distance = distance.ceil
    # If the map is scrolling from an event command, then use that scroll speed
    if scrolling? then @scroll_take_x = 2 ** @scroll_speed
    # If the map is not scrolling
    else
      # Make sure the distance is always divisible by 4
      if distance.ceil % 4 == 0 then @scroll_take_x = distance.ceil
      elsif distance.ceil % 4 <= 2 then @scroll_take_x = distance.ceil - distance.ceil % 4
      else @scroll_take_x = distance.ceil + (4 - (distance.ceil % 4)) end
    end
    # If scrolling coordinates are inside the map's boundaries
    unless @display_x + @scroll_remain_x + distance > (self.width - 20) * 128
      # Add onto the amount left to be scrolled
      @scroll_remain_x += distance
    end
  end
  #--------------------------------------------------------------------------
  # * Scroll Up
  #     distance : scroll distance
  #--------------------------------------------------------------------------
  def scroll_up(distance)
    # Ceil the distance
    distance = distance.ceil
    # If the map is scrolling from an event command, then use that scroll speed
    if scrolling? then @scroll_take_y = 2 ** @scroll_speed
    # If the map is not scrolling
    else
      # Make sure the distance is always divisible by 4
      if distance.ceil % 4 == 0 then @scroll_take_y = distance.ceil
      elsif distance.ceil % 4 <= 2 then @scroll_take_y = distance.ceil - distance.ceil % 4
      else @scroll_take_y = distance.ceil + (4 - (distance.ceil % 4)) end
    end
    # If scrolling coordinates are inside the map's boundaries
    unless @display_y - @scroll_remain_y - distance < 0
      # Add onto the amount left to be scrolled
      @scroll_remain_y -= distance
    end
  end
  #--------------------------------------------------------------------------
  # * Start Scroll
  #     direction : scroll direction
  #     distance  : scroll distance
  #     speed     : scroll speed
  #--------------------------------------------------------------------------
  def start_scroll(direction, distance, speed)
    # Set scrolling variables
    distance          = distance.ceil * 128
    @scroll_direction = direction
    @scroll_speed     = speed
    @scroll_rest      = distance
    # Execute scrolling
    case @scroll_direction
    when 2  # Down
      scroll_down(@scroll_rest)
    when 4  # Left
      scroll_left(@scroll_rest)
    when 6  # Right
      scroll_right(@scroll_rest)
    when 8  # Up
      scroll_up(@scroll_rest)
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  # This method could not be aliased because the scrolling part of the old
  # method has been rewritten.
  #--------------------------------------------------------------------------
  def update
    # Refresh map if necessary
    if $game_map.need_refresh
      refresh
    end
   
    #--------------------------------------------------------
    # If the map is still scrolling
    if @scroll_rest > 0 then @scroll_rest -= 2 ** @scroll_speed end
   
    # If the x axis needs to be scrolled to the right
    if @scroll_remain_x > 0
      # If the amount to be scrolled is close enough to 0 to decelerate
      if @scroll_remain_x <= @scroll_take_x * @deceleration_start
        old_display_x = @display_x
        # Add onto the deceleration variable
        @scroll_decel_x += @deceleration_speed
        # Work out how much to scroll
        distance = [@scroll_take_x - @scroll_decel_x, 4].max
        # If the scrolling coordinates are within the map's boundaries
        unless @display_x + distance > (self.width - 20) * 128
          @display_x += distance
        end
        # Subtract the amount that was scrolled
        @scroll_remain_x += old_display_x - @display_x
        if @scroll_remain_x < 0 then @scroll_remain_x = 0 end
      # Otherwise, scroll at a normal speed
      else
        # Reset the deceleration variable
        @scroll_decel_x = 0
        # If the scrolling coordinates are out of range
        if @display_x + @scroll_take_x > (self.width - 20) * 128
          @display_x = (self.width - 20) * 128
          @scroll_remain_x = 0
        # Otherwise, scroll normally
        else
          @display_x += @scroll_take_x
          @scroll_remain_x -= @scroll_take_x
        end
      end
      
    # If the x axis needs to be scrolled to the left
    elsif @scroll_remain_x < 0
      # If the amount to be scrolled is close enough to 0 to decelerate
      if @scroll_remain_x >= -@scroll_take_x * @deceleration_start
        old_display_x = @display_x
        # Add onto the deceleration variable
        @scroll_decel_x += @deceleration_speed
        # Work out how much to scroll
        distance = [@scroll_take_x - @scroll_decel_x, 4].max
        # If the scrolling coordinates are within the map's boundaries
        unless @display_x - distance < 0
          @display_x -= distance
        end
        # Subtract the amount that was scrolled
        @scroll_remain_x += old_display_x - @display_x
        if @scroll_remain_x > 0 then @scroll_remain_x = 0 end
      # Otherwise, scroll at a normal speed
      else
        # Reset the deceleration variable
        @scroll_decel_x = 0
        # If the scrolling coordinates are out of range
        if @display_x - @scroll_take_x < 0
          @display_x = 0
          @scroll_remain_x = 0
        # Otherwise, scroll normally
        else
          @display_x -= @scroll_take_x
          @scroll_remain_x += @scroll_take_x
        end
      end
   
    # If no x scrolling needs to be done, reset the deceleration variable
    else @scroll_decel_x = 0 end
   
    # If the y axis needs to be scrolled downwards
    if @scroll_remain_y > 0
      # If the amount to be scrolled is close enough to 0 to decelerate
      if @scroll_remain_y <= @scroll_take_y * @deceleration_start
        old_display_y = @display_y
        # Add onto the deceleration variable
        @scroll_decel_y += @deceleration_speed
        # Work out how much to scroll
        distance = [@scroll_take_y - @scroll_decel_y, 4].max
        # If the scrolling coordinates are within the map's boundaries
        unless @display_y + distance > (self.height - 15) * 128
          @display_y += distance
        end
        # Subtract the amount that was scrolled
        @scroll_remain_y += old_display_y - @display_y
        if @scroll_remain_y < 0 then @scroll_remain_y = 0 end
      # Otherwise, scroll at a normal speed
      else
        # Reset the deceleration variable
        @scroll_speed_accel_y = 0
        # If the scrolling coordinates are out of range
        if @display_y + @scroll_take_y > (self.height - 15) * 128
          @display_y = (self.height - 15) * 128
          @scroll_remain_y = 0
        # Otherwise, scroll normally
        else
          @display_y += @scroll_take_y
          @scroll_remain_y -= @scroll_take_y
        end
      end
   
    # If the y axis needs to be scrolled downwards
    elsif @scroll_remain_y < 0
      # If the amount to be scrolled is close enough to 0 to decelerate
      if @scroll_remain_y >= -@scroll_take_y * @deceleration_start
        old_display_y = @display_y
        # Add onto the deceleration variable
        @scroll_decel_y += @deceleration_speed
        # Work out how much to scroll
        distance = [@scroll_take_y - @scroll_decel_y, 4].max
        # If the scrolling coordinates are within the map's boundaries
        unless @display_y - distance < 0
          @display_y -= distance
        end
        # Subtract the amount that was scrolled
        @scroll_remain_y += old_display_y - @display_y
        if @scroll_remain_y > 0 then @scroll_remain_y = 0 end
      # Otherwise, scroll at a normal speed
      else
        # Reset the deceleration variable
        @scroll_speed_accel_y = 0
        # If the scrolling coordinates are out of range
        if @display_y - @scroll_take_y < 0
          @display_y = 0
          @scroll_remain_y = 0
        # Otherwise, scroll normally
        else
          @display_y -= @scroll_take_y
          @scroll_remain_y += @scroll_take_y
        end
      end
   
    # If no y scrolling needs to be done, reset the deceleration variable
    else @scroll_decel_y = 0 end
    #--------------------------------------------------------
   
    # Update map event
    for event in @events.values
      event.update
    end
    # Update common event
    for common_event in @common_events.values
      common_event.update
    end
    # Manage fog scrolling
    @fog_ox -= @fog_sx / 8.0
    @fog_oy -= @fog_sy / 8.0
    # Manage change in fog color tone
    if @fog_tone_duration >= 1
      d = @fog_tone_duration
      target = @fog_tone_target
      @fog_tone.red = (@fog_tone.red * (d - 1) + target.red) / d
      @fog_tone.green = (@fog_tone.green * (d - 1) + target.green) / d
      @fog_tone.blue = (@fog_tone.blue * (d - 1) + target.blue) / d
      @fog_tone.gray = (@fog_tone.gray * (d - 1) + target.gray) / d
      @fog_tone_duration -= 1
    end
    # Manage change in fog opacity level
    if @fog_opacity_duration >= 1
      d = @fog_opacity_duration
      @fog_opacity = (@fog_opacity * (d - 1) + @fog_opacity_target) / d
      @fog_opacity_duration -= 1
    end
  end
end

以下引用rongqingmei于2008-3-16 13:41:13的发言：

还有  跳跃事上面有东西就碰头  把重力脚本的第239行的
#----------------------自由落体--------------------------------
         if not $ud_ok
          @jumpnow -= 10
239行    if @jumpnow < 0     
          @jumpnow = [@jumpnow, -@JUMPMAX].max
         if not down1(((@x * 128 + @revise_x) / 128.0).round,
         ( (@y * 128 + @rev
0改为100000就解决了

感谢你~那个脚本有冲突就不用了~~
不过这个碰头的现象谢谢你了..可惜在不可通行的地方就用不得这个~到了不可通行的图块里就不能移动了~~

游戏正在向第一章发展.要不了几个星期了.因为只有星期6与星期7我可以制作.
希望大家多多包涵~

vmznxbc

又说18号放出，到今天还没出！

rongqingmei

还有  跳跃事上面有东西就碰头  把重力脚本的第239行的
#----------------------自由落体--------------------------------
          if not $ud_ok
           @jumpnow -= 10
  239行    if @jumpnow < 0     
           @jumpnow = [@jumpnow, -@JUMPMAX].max
          if not down1(((@x * 128 + @revise_x) / 128.0).round,
          ( (@y * 128 + @rev
0改为100000就解决了

rongqingmei

看了录象  真的好佩服你  可是也有许多美中不足的地方  像跳跃时屏幕一震一震的 我推荐个脚本

1. #==============================================================================
   
2. # ** Smooth_Scrolling
   
3. #------------------------------------------------------------------------------
   
4. #  Script by Toby Zerner
   
5. #  Gives scrolling a 'smooth' effect (deceleration).
   
6. #==============================================================================
   
7. 
   
8. class Game_Map
   
9.   attr_accessor :deceleration_start
   
10.   attr_accessor :deceleration_speed
    
11.   #--------------------------------------------------------------------------
    
12.   # * Setup
    
13.   #     map_id : map ID
    
14.   #--------------------------------------------------------------------------
    
15.   alias ss_setup setup
    
16.   def setup(map_id)
    
17.    
    
18.     # -- CONFIGURATION VARIABLES
    
19.     # When to start decelerating (bigger numbers mean ealier on) [default: 4]
    
20.     @deceleration_start = 13
    
21.     # How fast to decelerate (bigger numbers mean quicker) [default: 4]
    
22.     @deceleration_speed = 13
    
23.     # -- END CONFIGURATION VARIABLES
    
24.    
    
25.     # Call the old setup method
    
26.     ss_setup(map_id)
    
27.     # Initialize smooth scrolling variables
    
28.     # scroll_remain: the number of pixels * 4 the still need to be scrolled
    
29.     @scroll_remain_x = 0
    
30.     @scroll_remain_y = 0
    
31.     # scroll_take: the number of pixels * 4 that are being scrolled every frame
    
32.     #   i.e. scrolling speed
    
33.     @scroll_take_x = 0
    
34.     @scroll_take_y = 0
    
35.     # scroll_decel: variables for calculating decelaration
    
36.     @scroll_decel_x = 0
    
37.     @scroll_decel_y = 0
    
38.   end
    
39.   #--------------------------------------------------------------------------
    
40.   # * Scroll Down
    
41.   #     distance : scroll distance
    
42.   #--------------------------------------------------------------------------
    
43.   def scroll_down(distance)
    
44.     # Ceil the distance
    
45.     distance = distance.ceil
    
46.     # If the map is scrolling from an event command, then use that scroll speed
    
47.     if scrolling? then @scroll_take_y = 2 ** @scroll_speed
    
48.     # If the map is not scrolling
    
49.     else
    
50.       # Make sure the distance is always divisible by 4
    
51.       if distance.ceil % 4 == 0 then @scroll_take_y = distance.ceil
    
52.       elsif distance.ceil % 4 <= 2 then @scroll_take_y = distance.ceil - distance.ceil % 4
    
53.       else @scroll_take_y = distance.ceil + (4 - (distance.ceil % 4)) end
    
54.     end
    
55.     # If scrolling coordinates are inside the map's boundaries
    
56.     unless @display_y + @scroll_remain_y + distance > (self.height - 20) * 128
    
57.       # Add onto the amount left to be scrolled
    
58.       @scroll_remain_y += distance
    
59.     end
    
60.   end
    
61.   #--------------------------------------------------------------------------
    
62.   # * Scroll Left
    
63.   #     distance : scroll distance
    
64.   #--------------------------------------------------------------------------
    
65.   def scroll_left(distance)
    
66.     # Ceil the distance
    
67.     distance = distance.ceil
    
68.     # If the map is scrolling from an event command, then use that scroll speed
    
69.     if scrolling? then @scroll_take_x = 2 ** @scroll_speed
    
70.     # If the map is not scrolling
    
71.     else
    
72.       # Make sure the distance is always divisible by 4
    
73.       if distance.ceil % 4 == 0 then @scroll_take_x = distance.ceil
    
74.       elsif distance.ceil % 4 <= 2 then @scroll_take_x = distance.ceil - distance.ceil % 4
    
75.       else @scroll_take_x = distance.ceil + (4 - (distance.ceil % 4)) end
    
76.     end
    
77.     # If scrolling coordinates are inside the map's boundaries
    
78.     unless @display_x - @scroll_remain_x - distance < 0
    
79.       # Add onto the amount left to be scrolled
    
80.       @scroll_remain_x -= distance
    
81.     end
    
82.   end
    
83.   #--------------------------------------------------------------------------
    
84.   # * Scroll Right
    
85.   #     distance : scroll distance
    
86.   #--------------------------------------------------------------------------
    
87.   def scroll_right(distance)
    
88.     # Ceil the distance
    
89.     distance = distance.ceil
    
90.     # If the map is scrolling from an event command, then use that scroll speed
    
91.     if scrolling? then @scroll_take_x = 2 ** @scroll_speed
    
92.     # If the map is not scrolling
    
93.     else
    
94.       # Make sure the distance is always divisible by 4
    
95.       if distance.ceil % 4 == 0 then @scroll_take_x = distance.ceil
    
96.       elsif distance.ceil % 4 <= 2 then @scroll_take_x = distance.ceil - distance.ceil % 4
    
97.       else @scroll_take_x = distance.ceil + (4 - (distance.ceil % 4)) end
    
98.     end
    
99.     # If scrolling coordinates are inside the map's boundaries
    
100.     unless @display_x + @scroll_remain_x + distance > (self.width - 20) * 128
     
101.       # Add onto the amount left to be scrolled
     
102.       @scroll_remain_x += distance
     
103.     end
     
104.   end
     
105.   #--------------------------------------------------------------------------
     
106.   # * Scroll Up
     
107.   #     distance : scroll distance
     
108.   #--------------------------------------------------------------------------
     
109.   def scroll_up(distance)
     
110.     # Ceil the distance
     
111.     distance = distance.ceil
     
112.     # If the map is scrolling from an event command, then use that scroll speed
     
113.     if scrolling? then @scroll_take_y = 2 ** @scroll_speed
     
114.     # If the map is not scrolling
     
115.     else
     
116.       # Make sure the distance is always divisible by 4
     
117.       if distance.ceil % 4 == 0 then @scroll_take_y = distance.ceil
     
118.       elsif distance.ceil % 4 <= 2 then @scroll_take_y = distance.ceil - distance.ceil % 4
     
119.       else @scroll_take_y = distance.ceil + (4 - (distance.ceil % 4)) end
     
120.     end
     
121.     # If scrolling coordinates are inside the map's boundaries
     
122.     unless @display_y - @scroll_remain_y - distance < 0
     
123.       # Add onto the amount left to be scrolled
     
124.       @scroll_remain_y -= distance
     
125.     end
     
126.   end
     
127.   #--------------------------------------------------------------------------
     
128.   # * Start Scroll
     
129.   #     direction : scroll direction
     
130.   #     distance  : scroll distance
     
131.   #     speed     : scroll speed
     
132.   #--------------------------------------------------------------------------
     
133.   def start_scroll(direction, distance, speed)
     
134.     # Set scrolling variables
     
135.     distance          = distance.ceil * 128
     
136.     @scroll_direction = direction
     
137.     @scroll_speed     = speed
     
138.     @scroll_rest      = distance
     
139.     # Execute scrolling
     
140.     case @scroll_direction
     
141.     when 2  # Down
     
142.       scroll_down(@scroll_rest)
     
143.     when 4  # Left
     
144.       scroll_left(@scroll_rest)
     
145.     when 6  # Right
     
146.       scroll_right(@scroll_rest)
     
147.     when 8  # Up
     
148.       scroll_up(@scroll_rest)
     
149.     end
     
150.   end
     
151.   #--------------------------------------------------------------------------
     
152.   # * Frame Update
     
153.   #--------------------------------------------------------------------------
     
154.   # This method could not be aliased because the scrolling part of the old
     
155.   # method has been rewritten.
     
156.   #--------------------------------------------------------------------------
     
157.   def update
     
158.     # Refresh map if necessary
     
159.     if $game_map.need_refresh
     
160.       refresh
     
161.     end
     
162.    
     
163.     #--------------------------------------------------------
     
164.     # If the map is still scrolling
     
165.     if @scroll_rest > 0 then @scroll_rest -= 2 ** @scroll_speed end
     
166.    
     
167.     # If the x axis needs to be scrolled to the right
     
168.     if @scroll_remain_x > 0
     
169.       # If the amount to be scrolled is close enough to 0 to decelerate
     
170.       if @scroll_remain_x <= @scroll_take_x * @deceleration_start
     
171.         old_display_x = @display_x
     
172.         # Add onto the deceleration variable
     
173.         @scroll_decel_x += @deceleration_speed
     
174.         # Work out how much to scroll
     
175.         distance = [@scroll_take_x - @scroll_decel_x, 4].max
     
176.         # If the scrolling coordinates are within the map's boundaries
     
177.         unless @display_x + distance > (self.width - 20) * 128
     
178.           @display_x += distance
     
179.         end
     
180.         # Subtract the amount that was scrolled
     
181.         @scroll_remain_x += old_display_x - @display_x
     
182.         if @scroll_remain_x < 0 then @scroll_remain_x = 0 end
     
183.       # Otherwise, scroll at a normal speed
     
184.       else
     
185.         # Reset the deceleration variable
     
186.         @scroll_decel_x = 0
     
187.         # If the scrolling coordinates are out of range
     
188.         if @display_x + @scroll_take_x > (self.width - 20) * 128
     
189.           @display_x = (self.width - 20) * 128
     
190.           @scroll_remain_x = 0
     
191.         # Otherwise, scroll normally
     
192.         else
     
193.           @display_x += @scroll_take_x
     
194.           @scroll_remain_x -= @scroll_take_x
     
195.         end
     
196.       end
     
197.       
     
198.     # If the x axis needs to be scrolled to the left
     
199.     elsif @scroll_remain_x < 0
     
200.       # If the amount to be scrolled is close enough to 0 to decelerate
     
201.       if @scroll_remain_x >= -@scroll_take_x * @deceleration_start
     
202.         old_display_x = @display_x
     
203.         # Add onto the deceleration variable
     
204.         @scroll_decel_x += @deceleration_speed
     
205.         # Work out how much to scroll
     
206.         distance = [@scroll_take_x - @scroll_decel_x, 4].max
     
207.         # If the scrolling coordinates are within the map's boundaries
     
208.         unless @display_x - distance < 0
     
209.           @display_x -= distance
     
210.         end
     
211.         # Subtract the amount that was scrolled
     
212.         @scroll_remain_x += old_display_x - @display_x
     
213.         if @scroll_remain_x > 0 then @scroll_remain_x = 0 end
     
214.       # Otherwise, scroll at a normal speed
     
215.       else
     
216.         # Reset the deceleration variable
     
217.         @scroll_decel_x = 0
     
218.         # If the scrolling coordinates are out of range
     
219.         if @display_x - @scroll_take_x < 0
     
220.           @display_x = 0
     
221.           @scroll_remain_x = 0
     
222.         # Otherwise, scroll normally
     
223.         else
     
224.           @display_x -= @scroll_take_x
     
225.           @scroll_remain_x += @scroll_take_x
     
226.         end
     
227.       end
     
228.    
     
229.     # If no x scrolling needs to be done, reset the deceleration variable
     
230.     else @scroll_decel_x = 0 end
     
231.    
     
232.     # If the y axis needs to be scrolled downwards
     
233.     if @scroll_remain_y > 0
     
234.       # If the amount to be scrolled is close enough to 0 to decelerate
     
235.       if @scroll_remain_y <= @scroll_take_y * @deceleration_start
     
236.         old_display_y = @display_y
     
237.         # Add onto the deceleration variable
     
238.         @scroll_decel_y += @deceleration_speed
     
239.         # Work out how much to scroll
     
240.         distance = [@scroll_take_y - @scroll_decel_y, 4].max
     
241.         # If the scrolling coordinates are within the map's boundaries
     
242.         unless @display_y + distance > (self.height - 15) * 128
     
243.           @display_y += distance
     
244.         end
     
245.         # Subtract the amount that was scrolled
     
246.         @scroll_remain_y += old_display_y - @display_y
     
247.         if @scroll_remain_y < 0 then @scroll_remain_y = 0 end
     
248.       # Otherwise, scroll at a normal speed
     
249.       else
     
250.         # Reset the deceleration variable
     
251.         @scroll_speed_accel_y = 0
     
252.         # If the scrolling coordinates are out of range
     
253.         if @display_y + @scroll_take_y > (self.height - 15) * 128
     
254.           @display_y = (self.height - 15) * 128
     
255.           @scroll_remain_y = 0
     
256.         # Otherwise, scroll normally
     
257.         else
     
258.           @display_y += @scroll_take_y
     
259.           @scroll_remain_y -= @scroll_take_y
     
260.         end
     
261.       end
     
262.    
     
263.     # If the y axis needs to be scrolled downwards
     
264.     elsif @scroll_remain_y < 0
     
265.       # If the amount to be scrolled is close enough to 0 to decelerate
     
266.       if @scroll_remain_y >= -@scroll_take_y * @deceleration_start
     
267.         old_display_y = @display_y
     
268.         # Add onto the deceleration variable
     
269.         @scroll_decel_y += @deceleration_speed
     
270.         # Work out how much to scroll
     
271.         distance = [@scroll_take_y - @scroll_decel_y, 4].max
     
272.         # If the scrolling coordinates are within the map's boundaries
     
273.         unless @display_y - distance < 0
     
274.           @display_y -= distance
     
275.         end
     
276.         # Subtract the amount that was scrolled
     
277.         @scroll_remain_y += old_display_y - @display_y
     
278.         if @scroll_remain_y > 0 then @scroll_remain_y = 0 end
     
279.       # Otherwise, scroll at a normal speed
     
280.       else
     
281.         # Reset the deceleration variable
     
282.         @scroll_speed_accel_y = 0
     
283.         # If the scrolling coordinates are out of range
     
284.         if @display_y - @scroll_take_y < 0
     
285.           @display_y = 0
     
286.           @scroll_remain_y = 0
     
287.         # Otherwise, scroll normally
     
288.         else
     
289.           @display_y -= @scroll_take_y
     
290.           @scroll_remain_y += @scroll_take_y
     
291.         end
     
292.       end
     
293.    
     
294.     # If no y scrolling needs to be done, reset the deceleration variable
     
295.     else @scroll_decel_y = 0 end
     
296.     #--------------------------------------------------------
     
297.    
     
298.     # Update map event
     
299.     for event in @events.values
     
300.       event.update
     
301.     end
     
302.     # Update common event
     
303.     for common_event in @common_events.values
     
304.       common_event.update
     
305.     end
     
306.     # Manage fog scrolling
     
307.     @fog_ox -= @fog_sx / 8.0
     
308.     @fog_oy -= @fog_sy / 8.0
     
309.     # Manage change in fog color tone
     
310.     if @fog_tone_duration >= 1
     
311.       d = @fog_tone_duration
     
312.       target = @fog_tone_target
     
313.       @fog_tone.red = (@fog_tone.red * (d - 1) + target.red) / d
     
314.       @fog_tone.green = (@fog_tone.green * (d - 1) + target.green) / d
     
315.       @fog_tone.blue = (@fog_tone.blue * (d - 1) + target.blue) / d
     
316.       @fog_tone.gray = (@fog_tone.gray * (d - 1) + target.gray) / d
     
317.       @fog_tone_duration -= 1
     
318.     end
     
319.     # Manage change in fog opacity level
     
320.     if @fog_opacity_duration >= 1
     
321.       d = @fog_opacity_duration
     
322.       @fog_opacity = (@fog_opacity * (d - 1) + @fog_opacity_target) / d
     
323.       @fog_opacity_duration -= 1
     
324.     end
     
325.   end
     
326. end

复制代码

a86685356

额我下也下不到{/dk}{/dk}{/dk}{/dk}{/dk}

---

[RM=490,350][/RM]

冰鸷殛霰

那个......
带BB的测试版本....
我准备直接放出第一章........
正在准备第一章......

rongqingmei

希望 带BB的测试版本 能够解密  我们新来的研究研究

冰鸷殛霰

MS  66现在的人的气息越来越稀薄了-0-

孤独de思念

很期待  LZ的正式版