Refactored animation editor code into a single module

Data/Scripts/001_Technical/002_RubyUtilities.rb

@@ -127,6 +127,16 @@ module Enumerable
   end
 end
 
+#===============================================================================
+# Collision testing
+#===============================================================================
+class Rect < Object
+  def contains?(cx, cy)
+    return cx >= self.x && cx < self.x + self.width &&
+           cy >= self.y && cy < self.y + self.height
+  end
+end
+
 #===============================================================================
 # class File
 #===============================================================================

Data/Scripts/010_Data/002_PBS data/020_DungeonParameters.rb

@@ -53,7 +53,7 @@ module GameData
     extend ClassMethodsSymbols
     include InstanceMethods
 
-    # @param other [Symbol, String, self]
+    # @param area [Symbol, String, self]
     # @param version [Integer]
     # @return [self]
     def self.try_get(area, version = 0)

Data/Scripts/020_Debug/002_Animation editor/003_AnimEditor_Interpolation.rb

@@ -1,432 +1,436 @@
-#===============================================================================
+module BattleAnimationEditor
-# Paths and interpolation
+  module_function
-#===============================================================================
-class ControlPointSprite < Sprite
-  attr_accessor :dragging
 
-  def initialize(red, viewport = nil)
+  #===============================================================================
-    super(viewport)
+  # Paths and interpolation
-    self.bitmap = Bitmap.new(6, 6)
+  #===============================================================================
-    self.bitmap.fill_rect(0, 0, 6, 1, Color.black)
+  class ControlPointSprite < Sprite
-    self.bitmap.fill_rect(0, 0, 1, 6, Color.black)
+    attr_accessor :dragging
-    self.bitmap.fill_rect(0, 5, 6, 1, Color.black)
-    self.bitmap.fill_rect(5, 0, 1, 6, Color.black)
-    color = (red) ? Color.new(255, 0, 0) : Color.black
-    self.bitmap.fill_rect(2, 2, 2, 2, color)
-    self.x = -6
-    self.y = -6
-    self.visible = false
-    @dragging = false
-  end
 
-  def mouseover
+    def initialize(red, viewport = nil)
-    if Input.time?(Input::MOUSELEFT) == 0 || !@dragging
+      super(viewport)
+      self.bitmap = Bitmap.new(6, 6)
+      self.bitmap.fill_rect(0, 0, 6, 1, Color.black)
+      self.bitmap.fill_rect(0, 0, 1, 6, Color.black)
+      self.bitmap.fill_rect(0, 5, 6, 1, Color.black)
+      self.bitmap.fill_rect(5, 0, 1, 6, Color.black)
+      color = (red) ? Color.new(255, 0, 0) : Color.black
+      self.bitmap.fill_rect(2, 2, 2, 2, color)
+      self.x = -6
+      self.y = -6
+      self.visible = false
       @dragging = false
-      return
     end
-    mouse = Mouse.getMousePos(true)
-    return if !mouse
-    self.x = [[mouse[0], 0].max, 512].min
-    self.y = [[mouse[1], 0].max, 384].min
-  end
 
-  def hittest?
+    def mouseover
-    return true if !self.visible
+      if Input.time?(Input::MOUSELEFT) == 0 || !@dragging
-    mouse = Mouse.getMousePos(true)
+        @dragging = false
-    return false if !mouse
+        return
-    return mouse[0] >= self.x && mouse[0] < self.x + 6 &&
-           mouse[1] >= self.y && mouse[1] < self.y + 6
-  end
-
-  def inspect
-    return "[#{self.x},#{self.y}]"
-  end
-
-  def dispose
-    self.bitmap.dispose
-    super
-  end
-end
-
-#===============================================================================
-#
-#===============================================================================
-class PointSprite < Sprite
-  def initialize(x, y, viewport = nil)
-    super(viewport)
-    self.bitmap = Bitmap.new(2, 2)
-    self.bitmap.fill_rect(0, 0, 2, 2, Color.black)
-    self.x = x
-    self.y = y
-  end
-
-  def dispose
-    self.bitmap.dispose
-    super
-  end
-end
-
-#===============================================================================
-#
-#===============================================================================
-class PointPath
-  include Enumerable
-
-  def initialize
-    @points = []
-    @distances = []
-    @totaldist = 0
-  end
-
-  def [](x)
-    return @points[x].clone
-  end
-
-  def each
-    @points.each { |o| yield o.clone }
-  end
-
-  def size
-    return @points.size
-  end
-
-  def length
-    return @points.length
-  end
-
-  def totalDistance
-    return @totaldist
-  end
-
-  def inspect
-    p = []
-    @points.each do |point|
-      p.push([point[0].to_i, point[1].to_i])
-    end
-    return p.inspect
-  end
-
-  def isEndPoint?(x, y)
-    return false if @points.length == 0
-    index = @points.length - 1
-    return @points[index][0] == x &&
-           @points[index][1] == y
-  end
-
-  def addPoint(x, y)
-    @points.push([x, y])
-    if @points.length > 1
-      len = @points.length
-      dx = @points[len - 2][0] - @points[len - 1][0]
-      dy = @points[len - 2][1] - @points[len - 1][1]
-      dist = Math.sqrt((dx * dx) + (dy * dy))
-      @distances.push(dist)
-      @totaldist += dist
-    end
-  end
-
-  def clear
-    @points.clear
-    @distances.clear
-    @totaldist = 0
-  end
-
-  def smoothPointPath(frames, roundValues = false)
-    raise ArgumentError.new("frames out of range: #{frames}") if frames < 0
-    ret = PointPath.new
-    return ret if @points.length == 0
-    step = 1.0 / frames
-    t = 0.0
-    (frames + 2).times do
-      point = pointOnPath(t)
-      if roundValues
-        ret.addPoint(point[0].round, point[1].round)
-      else
-        ret.addPoint(point[0], point[1])
       end
-      t += step
+      mouse = Mouse.getMousePos(true)
-      t = [1.0, t].min
+      return if !mouse
+      self.x = [[mouse[0], 0].max, 512].min
+      self.y = [[mouse[1], 0].max, 384].min
+    end
+
+    def hittest?
+      return true if !self.visible
+      mouse = Mouse.getMousePos(true)
+      return false if !mouse
+      return mouse[0] >= self.x && mouse[0] < self.x + 6 &&
+             mouse[1] >= self.y && mouse[1] < self.y + 6
+    end
+
+    def inspect
+      return "[#{self.x},#{self.y}]"
+    end
+
+    def dispose
+      self.bitmap.dispose
+      super
     end
-    return ret
   end
 
-  def pointOnPath(t)
+  #===============================================================================
-    if t < 0 || t > 1
+  #
-      raise ArgumentError.new("t out of range for pointOnPath: #{t}")
+  #===============================================================================
+  class PointSprite < Sprite
+    def initialize(x, y, viewport = nil)
+      super(viewport)
+      self.bitmap = Bitmap.new(2, 2)
+      self.bitmap.fill_rect(0, 0, 2, 2, Color.black)
+      self.x = x
+      self.y = y
     end
-    return nil if @points.length == 0
+
-    ret = @points[@points.length - 1].clone
+    def dispose
-    return ret if @points.length == 1
+      self.bitmap.dispose
-    curdist = 0
+      super
-    distForT = @totaldist * t
+    end
-    i = 0
+  end
-    @distances.each do |dist|
+
-      curdist += dist
+  #===============================================================================
-      if dist > 0.0 && curdist >= distForT
+  #
-        distT = 1.0 - ((curdist - distForT) / dist)
+  #===============================================================================
-        dx = @points[i + 1][0] - @points[i][0]
+  class PointPath
-        dy = @points[i + 1][1] - @points[i][1]
+    include Enumerable
-        ret = [@points[i][0] + (dx * distT),
+
-               @points[i][1] + (dy * distT)]
+    def initialize
-        break
+      @points = []
+      @distances = []
+      @totaldist = 0
+    end
+
+    def [](x)
+      return @points[x].clone
+    end
+
+    def each
+      @points.each { |o| yield o.clone }
+    end
+
+    def size
+      return @points.size
+    end
+
+    def length
+      return @points.length
+    end
+
+    def totalDistance
+      return @totaldist
+    end
+
+    def inspect
+      p = []
+      @points.each do |point|
+        p.push([point[0].to_i, point[1].to_i])
       end
-      i += 1
+      return p.inspect
     end
-    return ret
-  end
-end
 
-#===============================================================================
+    def isEndPoint?(x, y)
-#
+      return false if @points.length == 0
-#===============================================================================
+      index = @points.length - 1
-def catmullRom(p1, p2, p3, p4, t)
+      return @points[index][0] == x &&
-  # p1=prevPoint, p2=startPoint, p3=endPoint, p4=nextPoint, t is from 0 through 1
+             @points[index][1] == y
-  t2 = t * t
+    end
-  t3 = t2 * t
-  return 0.5 * ((2 * p2) + (t * (p3 - p1)) +
-         (t2 * ((2 * p1) - (5 * p2) + (4 * p3) - p4)) +
-         (t3 * (p4 - (3 * p3) + (3 * p2) - p1)))
-end
 
-def getCatmullRomPoint(src, t)
+    def addPoint(x, y)
-  x = 0, y = 0
+      @points.push([x, y])
-  t *= 3.0
+      if @points.length > 1
-  if t < 1.0
+        len = @points.length
-    x = catmullRom(src[0].x, src[0].x, src[1].x, src[2].x, t)
+        dx = @points[len - 2][0] - @points[len - 1][0]
-    y = catmullRom(src[0].y, src[0].y, src[1].y, src[2].y, t)
+        dy = @points[len - 2][1] - @points[len - 1][1]
-  elsif t < 2.0
+        dist = Math.sqrt((dx * dx) + (dy * dy))
-    t -= 1.0
+        @distances.push(dist)
-    x = catmullRom(src[0].x, src[1].x, src[2].x, src[3].x, t)
+        @totaldist += dist
-    y = catmullRom(src[0].y, src[1].y, src[2].y, src[3].y, t)
+      end
-  else
+    end
-    t -= 2.0
-    x = catmullRom(src[1].x, src[2].x, src[3].x, src[3].x, t)
-    y = catmullRom(src[1].y, src[2].y, src[3].y, src[3].y, t)
-  end
-  return [x, y]
-end
 
-def getCurvePoint(src, t)
+    def clear
-  return getCatmullRomPoint(src, t)
+      @points.clear
-end
+      @distances.clear
+      @totaldist = 0
+    end
 
-def curveToPointPath(curve, numpoints)
+    def smoothPointPath(frames, roundValues = false)
-  return nil if numpoints < 2
+      raise ArgumentError.new("frames out of range: #{frames}") if frames < 0
-  path = PointPath.new
+      ret = PointPath.new
-  step = 1.0 / (numpoints - 1)
+      return ret if @points.length == 0
-  t = 0.0
+      step = 1.0 / frames
-  numpoints.times do
+      t = 0.0
-    point = getCurvePoint(curve, t)
+      (frames + 2).times do
-    path.addPoint(point[0], point[1])
+        point = pointOnPath(t)
-    t += step
+        if roundValues
-  end
+          ret.addPoint(point[0].round, point[1].round)
-  return path
+        else
-end
+          ret.addPoint(point[0], point[1])
-
-def pbDefinePath(canvas)
-  sliderwin2 = ControlWindow.new(0, 0, 320, 320)
-  sliderwin2.viewport = canvas.viewport
-  sliderwin2.addSlider(_INTL("Number of frames:"), 2, 500, 20)
-  sliderwin2.opacity = 200
-  defcurvebutton = sliderwin2.addButton(_INTL("Define Smooth Curve"))
-  defpathbutton = sliderwin2.addButton(_INTL("Define Freehand Path"))
-  okbutton = sliderwin2.addButton(_INTL("OK"))
-  cancelbutton = sliderwin2.addButton(_INTL("Cancel"))
-  points = []
-  path = nil
-  loop do
-    Graphics.update
-    Input.update
-    sliderwin2.update
-    if sliderwin2.changed?(0) # Number of frames
-      if path
-        path = path.smoothPointPath(sliderwin2.value(0), false)
-        i = 0
-        path.each do |point|
-          if i < points.length
-            points[i].x = point[0]
-            points[i].y = point[1]
-          else
-            points.push(PointSprite.new(point[0], point[1], canvas.viewport))
-          end
-          i += 1
         end
-        (i...points.length).each do |j|
+        t += step
-          points[j].dispose
+        t = [1.0, t].min
-          points[j] = nil
-        end
-        points.compact!
       end
-    elsif sliderwin2.changed?(defcurvebutton)
+      return ret
-      points.each do |point|
+    end
-        point.dispose
+
+    def pointOnPath(t)
+      if t < 0 || t > 1
+        raise ArgumentError.new("t out of range for pointOnPath: #{t}")
       end
-      points.clear
+      return nil if @points.length == 0
-      30.times do
+      ret = @points[@points.length - 1].clone
-        point = PointSprite.new(0, 0, canvas.viewport)
+      return ret if @points.length == 1
-        point.visible = false
+      curdist = 0
-        points.push(point)
+      distForT = @totaldist * t
-      end
+      i = 0
-      curve = [
+      @distances.each do |dist|
-        ControlPointSprite.new(true, canvas.viewport),
+        curdist += dist
-        ControlPointSprite.new(false, canvas.viewport),
+        if dist > 0.0 && curdist >= distForT
-        ControlPointSprite.new(false, canvas.viewport),
+          distT = 1.0 - ((curdist - distForT) / dist)
-        ControlPointSprite.new(true, canvas.viewport)
+          dx = @points[i + 1][0] - @points[i][0]
-      ]
+          dy = @points[i + 1][1] - @points[i][1]
-      showline = false
+          ret = [@points[i][0] + (dx * distT),
-      sliderwin2.visible = false
+                 @points[i][1] + (dy * distT)]
-      # This window displays the mouse's current position
-      window = Window_UnformattedTextPokemon.newWithSize(
-        "", 0, 320 - 64, 128, 64, canvas.viewport
-      )
-      loop do
-        Graphics.update
-        Input.update
-        if Input.trigger?(Input::BACK)
           break
         end
-        if Input.trigger?(Input::MOUSELEFT)
+        i += 1
+      end
+      return ret
+    end
+  end
+
+  #===============================================================================
+  #
+  #===============================================================================
+  def catmullRom(p1, p2, p3, p4, t)
+    # p1=prevPoint, p2=startPoint, p3=endPoint, p4=nextPoint, t is from 0 through 1
+    t2 = t * t
+    t3 = t2 * t
+    return 0.5 * ((2 * p2) + (t * (p3 - p1)) +
+           (t2 * ((2 * p1) - (5 * p2) + (4 * p3) - p4)) +
+           (t3 * (p4 - (3 * p3) + (3 * p2) - p1)))
+  end
+
+  def getCatmullRomPoint(src, t)
+    x = 0, y = 0
+    t *= 3.0
+    if t < 1.0
+      x = catmullRom(src[0].x, src[0].x, src[1].x, src[2].x, t)
+      y = catmullRom(src[0].y, src[0].y, src[1].y, src[2].y, t)
+    elsif t < 2.0
+      t -= 1.0
+      x = catmullRom(src[0].x, src[1].x, src[2].x, src[3].x, t)
+      y = catmullRom(src[0].y, src[1].y, src[2].y, src[3].y, t)
+    else
+      t -= 2.0
+      x = catmullRom(src[1].x, src[2].x, src[3].x, src[3].x, t)
+      y = catmullRom(src[1].y, src[2].y, src[3].y, src[3].y, t)
+    end
+    return [x, y]
+  end
+
+  def getCurvePoint(src, t)
+    return getCatmullRomPoint(src, t)
+  end
+
+  def curveToPointPath(curve, numpoints)
+    return nil if numpoints < 2
+    path = PointPath.new
+    step = 1.0 / (numpoints - 1)
+    t = 0.0
+    numpoints.times do
+      point = getCurvePoint(curve, t)
+      path.addPoint(point[0], point[1])
+      t += step
+    end
+    return path
+  end
+
+  def pbDefinePath(canvas)
+    sliderwin2 = ControlWindow.new(0, 0, 320, 320)
+    sliderwin2.viewport = canvas.viewport
+    sliderwin2.addSlider(_INTL("Number of frames:"), 2, 500, 20)
+    sliderwin2.opacity = 200
+    defcurvebutton = sliderwin2.addButton(_INTL("Define Smooth Curve"))
+    defpathbutton = sliderwin2.addButton(_INTL("Define Freehand Path"))
+    okbutton = sliderwin2.addButton(_INTL("OK"))
+    cancelbutton = sliderwin2.addButton(_INTL("Cancel"))
+    points = []
+    path = nil
+    loop do
+      Graphics.update
+      Input.update
+      sliderwin2.update
+      if sliderwin2.changed?(0) # Number of frames
+        if path
+          path = path.smoothPointPath(sliderwin2.value(0), false)
+          i = 0
+          path.each do |point|
+            if i < points.length
+              points[i].x = point[0]
+              points[i].y = point[1]
+            else
+              points.push(PointSprite.new(point[0], point[1], canvas.viewport))
+            end
+            i += 1
+          end
+          (i...points.length).each do |j|
+            points[j].dispose
+            points[j] = nil
+          end
+          points.compact!
+        end
+      elsif sliderwin2.changed?(defcurvebutton)
+        points.each do |point|
+          point.dispose
+        end
+        points.clear
+        30.times do
+          point = PointSprite.new(0, 0, canvas.viewport)
+          point.visible = false
+          points.push(point)
+        end
+        curve = [
+          ControlPointSprite.new(true, canvas.viewport),
+          ControlPointSprite.new(false, canvas.viewport),
+          ControlPointSprite.new(false, canvas.viewport),
+          ControlPointSprite.new(true, canvas.viewport)
+        ]
+        showline = false
+        sliderwin2.visible = false
+        # This window displays the mouse's current position
+        window = Window_UnformattedTextPokemon.newWithSize(
+          "", 0, 320 - 64, 128, 64, canvas.viewport
+        )
+        loop do
+          Graphics.update
+          Input.update
+          if Input.trigger?(Input::BACK)
+            break
+          end
+          if Input.trigger?(Input::MOUSELEFT)
+            4.times do |j|
+              next if !curve[j].hittest?
+              if [1, 2].include?(j) && (!curve[0].visible || !curve[3].visible)
+                next
+              end
+              curve[j].visible = true
+              4.times do |k|
+                curve[k].dragging = (k == j)
+              end
+              break
+            end
+          end
           4.times do |j|
-            next if !curve[j].hittest?
+            curve[j].mouseover
-            if [1, 2].include?(j) && (!curve[0].visible || !curve[3].visible)
+          end
-              next
+          mousepos = Mouse.getMousePos(true)
+          newtext = (mousepos) ? sprintf("(%d,%d)", mousepos[0], mousepos[1]) : "(??,??)"
+          window.text = newtext if window.text != newtext
+          if curve[0].visible && curve[3].visible &&
+             !curve[0].dragging && !curve[3].dragging
+            points.each do |point|
+              point.visible = true
             end
-            curve[j].visible = true
+            if !showline
-            4.times do |k|
+              curve[1].visible = true
-              curve[k].dragging = (k == j)
+              curve[2].visible = true
+              curve[1].x = curve[0].x + (0.3333 * (curve[3].x - curve[0].x))
+              curve[1].y = curve[0].y + (0.3333 * (curve[3].y - curve[0].y))
+              curve[2].x = curve[0].x + (0.6666 * (curve[3].x - curve[0].x))
+              curve[2].y = curve[0].y + (0.6666 * (curve[3].y - curve[0].y))
             end
+            showline = true
+          end
+          if showline
+            step = 1.0 / (points.length - 1)
+            t = 0.0
+            points.length.times do |j|
+              point = getCurvePoint(curve, t)
+              points[j].x = point[0]
+              points[j].y = point[1]
+              t += step
+            end
+          end
+        end
+        window.dispose
+        # dispose temporary path
+        points.each do |point|
+          point.dispose
+        end
+        points.clear
+        if showline
+          path = curveToPointPath(curve, sliderwin2.value(0))
+  #       File.open("pointpath.txt","wb") { |f| f.write(path.inspect) }
+          path.each do |point|
+            points.push(PointSprite.new(point[0], point[1], canvas.viewport))
+          end
+        end
+        curve.each do |point|
+          point.dispose
+        end
+        sliderwin2.visible = true
+        next
+      elsif sliderwin2.changed?(defpathbutton)
+        canceled = false
+        pointpath = PointPath.new
+        points.each do |point|
+          point.dispose
+        end
+        points.clear
+        window = Window_UnformattedTextPokemon.newWithSize(
+          "", 0, 320 - 64, 128, 64, canvas.viewport
+        )
+        sliderwin2.visible = false
+        loop do
+          Graphics.update
+          Input.update
+          if Input.triggerex?(:ESCAPE)
+            canceled = true
+            break
+          end
+          if Input.trigger?(Input::MOUSELEFT)
+            break
+          end
+          mousepos = Mouse.getMousePos(true)
+          window.text = (mousepos) ? sprintf("(%d,%d)", mousepos[0], mousepos[1]) : "(??,??)"
+        end
+        until canceled
+          mousepos = Mouse.getMousePos(true)
+          if mousepos && !pointpath.isEndPoint?(mousepos[0], mousepos[1])
+            pointpath.addPoint(mousepos[0], mousepos[1])
+            points.push(PointSprite.new(mousepos[0], mousepos[1], canvas.viewport))
+          end
+          window.text = (mousepos) ? sprintf("(%d,%d)", mousepos[0], mousepos[1]) : "(??,??)"
+          Graphics.update
+          Input.update
+          if Input.triggerex?(:ESCAPE) || Input.time?(Input::MOUSELEFT) == 0
             break
           end
         end
-        4.times do |j|
+        window.dispose
-          curve[j].mouseover
+        # dispose temporary path
+        points.each do |point|
+          point.dispose
         end
-        mousepos = Mouse.getMousePos(true)
+        points.clear
-        newtext = (mousepos) ? sprintf("(%d,%d)", mousepos[0], mousepos[1]) : "(??,??)"
+        # generate smooth path from temporary path
-        window.text = newtext if window.text != newtext
+        path = pointpath.smoothPointPath(sliderwin2.value(0), true)
-        if curve[0].visible && curve[3].visible &&
+        # redraw path from smooth path
-           !curve[0].dragging && !curve[3].dragging
-          points.each do |point|
-            point.visible = true
-          end
-          if !showline
-            curve[1].visible = true
-            curve[2].visible = true
-            curve[1].x = curve[0].x + (0.3333 * (curve[3].x - curve[0].x))
-            curve[1].y = curve[0].y + (0.3333 * (curve[3].y - curve[0].y))
-            curve[2].x = curve[0].x + (0.6666 * (curve[3].x - curve[0].x))
-            curve[2].y = curve[0].y + (0.6666 * (curve[3].y - curve[0].y))
-          end
-          showline = true
-        end
-        if showline
-          step = 1.0 / (points.length - 1)
-          t = 0.0
-          points.length.times do |j|
-            point = getCurvePoint(curve, t)
-            points[j].x = point[0]
-            points[j].y = point[1]
-            t += step
-          end
-        end
-      end
-      window.dispose
-      # dispose temporary path
-      points.each do |point|
-        point.dispose
-      end
-      points.clear
-      if showline
-        path = curveToPointPath(curve, sliderwin2.value(0))
-#       File.open("pointpath.txt","wb") { |f| f.write(path.inspect) }
         path.each do |point|
           points.push(PointSprite.new(point[0], point[1], canvas.viewport))
         end
-      end
+  #     File.open("pointpath.txt","wb") { |f| f.write(path.inspect) }
-      curve.each do |point|
+        sliderwin2.visible = true
-        point.dispose
+        next
-      end
+      elsif sliderwin2.changed?(okbutton) && path
-      sliderwin2.visible = true
+  #     File.open("pointpath.txt","wb") { |f| f.write(path.inspect) }
-      next
+        neededsize = canvas.currentframe + sliderwin2.value(0)
-    elsif sliderwin2.changed?(defpathbutton)
+        if neededsize > canvas.animation.length
-      canceled = false
+          canvas.animation.resize(neededsize)
-      pointpath = PointPath.new
-      points.each do |point|
-        point.dispose
-      end
-      points.clear
-      window = Window_UnformattedTextPokemon.newWithSize(
-        "", 0, 320 - 64, 128, 64, canvas.viewport
-      )
-      sliderwin2.visible = false
-      loop do
-        Graphics.update
-        Input.update
-        if Input.triggerex?(:ESCAPE)
-          canceled = true
-          break
         end
-        if Input.trigger?(Input::MOUSELEFT)
+        thiscel = canvas.currentCel
-          break
+        celnumber = canvas.currentcel
+        (canvas.currentframe...neededsize).each do |j|
+          cel = canvas.animation[j][celnumber]
+          if !canvas.animation[j][celnumber]
+            cel = pbCreateCel(0, 0, thiscel[AnimFrame::PATTERN], canvas.animation.position)
+            canvas.animation[j][celnumber] = cel
+          end
+          cel[AnimFrame::X] = path[j - canvas.currentframe][0]
+          cel[AnimFrame::Y] = path[j - canvas.currentframe][1]
         end
-        mousepos = Mouse.getMousePos(true)
+        break
-        window.text = (mousepos) ? sprintf("(%d,%d)", mousepos[0], mousepos[1]) : "(??,??)"
+      elsif sliderwin2.changed?(cancelbutton) || Input.trigger?(Input::BACK)
+        break
       end
-      until canceled
-        mousepos = Mouse.getMousePos(true)
-        if mousepos && !pointpath.isEndPoint?(mousepos[0], mousepos[1])
-          pointpath.addPoint(mousepos[0], mousepos[1])
-          points.push(PointSprite.new(mousepos[0], mousepos[1], canvas.viewport))
-        end
-        window.text = (mousepos) ? sprintf("(%d,%d)", mousepos[0], mousepos[1]) : "(??,??)"
-        Graphics.update
-        Input.update
-        if Input.triggerex?(:ESCAPE) || Input.time?(Input::MOUSELEFT) == 0
-          break
-        end
-      end
-      window.dispose
-      # dispose temporary path
-      points.each do |point|
-        point.dispose
-      end
-      points.clear
-      # generate smooth path from temporary path
-      path = pointpath.smoothPointPath(sliderwin2.value(0), true)
-      # redraw path from smooth path
-      path.each do |point|
-        points.push(PointSprite.new(point[0], point[1], canvas.viewport))
-      end
-#     File.open("pointpath.txt","wb") { |f| f.write(path.inspect) }
-      sliderwin2.visible = true
-      next
-    elsif sliderwin2.changed?(okbutton) && path
-#     File.open("pointpath.txt","wb") { |f| f.write(path.inspect) }
-      neededsize = canvas.currentframe + sliderwin2.value(0)
-      if neededsize > canvas.animation.length
-        canvas.animation.resize(neededsize)
-      end
-      thiscel = canvas.currentCel
-      celnumber = canvas.currentcel
-      (canvas.currentframe...neededsize).each do |j|
-        cel = canvas.animation[j][celnumber]
-        if !canvas.animation[j][celnumber]
-          cel = pbCreateCel(0, 0, thiscel[AnimFrame::PATTERN], canvas.animation.position)
-          canvas.animation[j][celnumber] = cel
-        end
-        cel[AnimFrame::X] = path[j - canvas.currentframe][0]
-        cel[AnimFrame::Y] = path[j - canvas.currentframe][1]
-      end
-      break
-    elsif sliderwin2.changed?(cancelbutton) || Input.trigger?(Input::BACK)
-      break
     end
+    # dispose all points
+    points.each do |point|
+      point.dispose
+    end
+    points.clear
+    sliderwin2.dispose
+    return
   end
-  # dispose all points
-  points.each do |point|
-    point.dispose
-  end
-  points.clear
-  sliderwin2.dispose
-  return
 end

Data/Scripts/020_Debug/002_Animation editor/004_AnimEditor_ExportImport.rb

@@ -1,143 +1,147 @@
-################################################################################
+module BattleAnimationEditor
-# Importing and exporting
+  module_function
-################################################################################
-def pbRgssChdir(dir)
-  RTP.eachPathFor(dir) { |path| Dir.chdir(path) { yield } }
-end
 
-def tryLoadData(file)
+  ################################################################################
-  begin
+  # Importing and exporting
-    return load_data(file)
+  ################################################################################
-  rescue
+  def pbRgssChdir(dir)
-    return nil
+    RTP.eachPathFor(dir) { |path| Dir.chdir(path) { yield } }
   end
-end
 
-def dumpBase64Anim(s)
+  def tryLoadData(file)
-  return [Zlib::Deflate.deflate(Marshal.dump(s))].pack("m").gsub(/\n/, "\r\n")
-end
-
-def loadBase64Anim(s)
-  return Marshal.restore(Zlib::Inflate.inflate(s.unpack("m")[0]))
-end
-
-def pbExportAnim(animations)
-  filename = pbMessageFreeText(_INTL("Enter a filename."), "", false, 32)
-  if filename != ""
     begin
-      filename += ".anm"
+      return load_data(file)
-      File.open(filename, "wb") do |f|
-        f.write(dumpBase64Anim(animations[animations.selected]))
-      end
-      failed = false
     rescue
-      pbMessage(_INTL("Couldn't save the animation to {1}.", filename))
+      return nil
-      failed = true
-    end
-    if !failed
-      pbMessage(_INTL("Animation was saved to {1} in the game folder.", filename))
-      pbMessage(_INTL("It's a text file, so it can be transferred to others easily."))
     end
   end
-end
 
-def pbImportAnim(animations, canvas, animwin)
+  def dumpBase64Anim(s)
-  animfiles = []
+    return [Zlib::Deflate.deflate(Marshal.dump(s))].pack("m").gsub(/\n/, "\r\n")
-  pbRgssChdir(".") { animfiles.concat(Dir.glob("*.anm")) }
+  end
-  cmdwin = pbListWindow(animfiles, 320)
+
-  cmdwin.opacity = 200
+  def loadBase64Anim(s)
-  cmdwin.height = 480
+    return Marshal.restore(Zlib::Inflate.inflate(s.unpack("m")[0]))
-  cmdwin.viewport = canvas.viewport
+  end
-  loop do
+
-    Graphics.update
+  def pbExportAnim(animations)
-    Input.update
+    filename = pbMessageFreeText(_INTL("Enter a filename."), "", false, 32)
-    cmdwin.update
+    if filename != ""
-    if Input.trigger?(Input::USE) && animfiles.length > 0
       begin
-        textdata = loadBase64Anim(IO.read(animfiles[cmdwin.index]))
+        filename += ".anm"
-        throw "Bad data" if !textdata.is_a?(PBAnimation)
+        File.open(filename, "wb") do |f|
-        textdata.id = -1 # this is not an RPG Maker XP animation
+          f.write(dumpBase64Anim(animations[animations.selected]))
-        pbConvertAnimToNewFormat(textdata)
+        end
-        animations[animations.selected] = textdata
+        failed = false
       rescue
-        pbMessage(_INTL("The animation is invalid or could not be loaded."))
+        pbMessage(_INTL("Couldn't save the animation to {1}.", filename))
-        next
+        failed = true
       end
-      graphic = animations[animations.selected].graphic
+      if !failed
-      graphic = "Graphics/Animations/#{graphic}"
+        pbMessage(_INTL("Animation was saved to {1} in the game folder.", filename))
-      if graphic && graphic != "" && !FileTest.image_exist?(graphic)
+        pbMessage(_INTL("It's a text file, so it can be transferred to others easily."))
-        pbMessage(_INTL("The animation file {1} was not found. The animation will load anyway.", graphic))
       end
-      canvas.loadAnimation(animations[animations.selected])
-      animwin.animbitmap = canvas.animbitmap
-      break
-    end
-    if Input.trigger?(Input::BACK)
-      break
     end
   end
-  cmdwin.dispose
-  return
-end
 
-################################################################################
+  def pbImportAnim(animations, canvas, animwin)
-# Format conversion
+    animfiles = []
-################################################################################
+    pbRgssChdir(".") { animfiles.concat(Dir.glob("*.anm")) }
-def pbConvertAnimToNewFormat(textdata)
+    cmdwin = pbListWindow(animfiles, 320)
-  needconverting = false
+    cmdwin.opacity = 200
-  textdata.length.times do |i|
+    cmdwin.height = 480
-    next if !textdata[i]
+    cmdwin.viewport = canvas.viewport
-    PBAnimation::MAX_SPRITES.times do |j|
+    loop do
-      next if !textdata[i][j]
+      Graphics.update
-      needconverting = true if textdata[i][j][AnimFrame::FOCUS].nil?
+      Input.update
-      break if needconverting
+      cmdwin.update
+      if Input.trigger?(Input::USE) && animfiles.length > 0
+        begin
+          textdata = loadBase64Anim(IO.read(animfiles[cmdwin.index]))
+          throw "Bad data" if !textdata.is_a?(PBAnimation)
+          textdata.id = -1 # this is not an RPG Maker XP animation
+          pbConvertAnimToNewFormat(textdata)
+          animations[animations.selected] = textdata
+        rescue
+          pbMessage(_INTL("The animation is invalid or could not be loaded."))
+          next
+        end
+        graphic = animations[animations.selected].graphic
+        graphic = "Graphics/Animations/#{graphic}"
+        if graphic && graphic != "" && !FileTest.image_exist?(graphic)
+          pbMessage(_INTL("The animation file {1} was not found. The animation will load anyway.", graphic))
+        end
+        canvas.loadAnimation(animations[animations.selected])
+        animwin.animbitmap = canvas.animbitmap
+        break
+      end
+      if Input.trigger?(Input::BACK)
+        break
+      end
     end
-    break if needconverting
+    cmdwin.dispose
+    return
   end
-  if needconverting
+
+  ################################################################################
+  # Format conversion
+  ################################################################################
+  def pbConvertAnimToNewFormat(textdata)
+    needconverting = false
     textdata.length.times do |i|
       next if !textdata[i]
       PBAnimation::MAX_SPRITES.times do |j|
         next if !textdata[i][j]
-        textdata[i][j][AnimFrame::PRIORITY] = 1 if textdata[i][j][AnimFrame::PRIORITY].nil?
+        needconverting = true if textdata[i][j][AnimFrame::FOCUS].nil?
-        case j
+        break if needconverting
-        when 0      # User battler
+      end
-          textdata[i][j][AnimFrame::FOCUS] = 2
+      break if needconverting
-          textdata[i][j][AnimFrame::X] = Battle::Scene::FOCUSUSER_X
+    end
-          textdata[i][j][AnimFrame::Y] = Battle::Scene::FOCUSUSER_Y
+    if needconverting
-        when 1   # Target battler
+      textdata.length.times do |i|
-          textdata[i][j][AnimFrame::FOCUS] = 1
+        next if !textdata[i]
-          textdata[i][j][AnimFrame::X] = Battle::Scene::FOCUSTARGET_X
+        PBAnimation::MAX_SPRITES.times do |j|
-          textdata[i][j][AnimFrame::Y] = Battle::Scene::FOCUSTARGET_Y
+          next if !textdata[i][j]
-        else
+          textdata[i][j][AnimFrame::PRIORITY] = 1 if textdata[i][j][AnimFrame::PRIORITY].nil?
-          textdata[i][j][AnimFrame::FOCUS] = (textdata.position || 4)
+          case j
-          if textdata.position == 1
+          when 0      # User battler
-            textdata[i][j][AnimFrame::X] += Battle::Scene::FOCUSTARGET_X
+            textdata[i][j][AnimFrame::FOCUS] = 2
-            textdata[i][j][AnimFrame::Y] += Battle::Scene::FOCUSTARGET_Y - 2
+            textdata[i][j][AnimFrame::X] = Battle::Scene::FOCUSUSER_X
+            textdata[i][j][AnimFrame::Y] = Battle::Scene::FOCUSUSER_Y
+          when 1   # Target battler
+            textdata[i][j][AnimFrame::FOCUS] = 1
+            textdata[i][j][AnimFrame::X] = Battle::Scene::FOCUSTARGET_X
+            textdata[i][j][AnimFrame::Y] = Battle::Scene::FOCUSTARGET_Y
+          else
+            textdata[i][j][AnimFrame::FOCUS] = (textdata.position || 4)
+            if textdata.position == 1
+              textdata[i][j][AnimFrame::X] += Battle::Scene::FOCUSTARGET_X
+              textdata[i][j][AnimFrame::Y] += Battle::Scene::FOCUSTARGET_Y - 2
+            end
           end
         end
       end
     end
+    return needconverting
   end
-  return needconverting
-end
 
-def pbConvertAnimsToNewFormat
+  def pbConvertAnimsToNewFormat
-  pbMessage(_INTL("Will convert animations now."))
+    pbMessage(_INTL("Will convert animations now."))
-  count = 0
+    count = 0
-  animations = pbLoadBattleAnimations
+    animations = pbLoadBattleAnimations
-  if !animations || !animations[0]
+    if !animations || !animations[0]
-    pbMessage(_INTL("No animations exist."))
+      pbMessage(_INTL("No animations exist."))
-    return
+      return
+    end
+    animations.length.times do |k|
+      next if !animations[k]
+      ret = pbConvertAnimToNewFormat(animations[k])
+      count += 1 if ret
+    end
+    if count > 0
+      save_data(animations, "Data/PkmnAnimations.rxdata")
+      $game_temp.battle_animations_data = nil
+    end
+    pbMessage(_INTL("{1} animations converted to new format.", count))
   end
-  animations.length.times do |k|
-    next if !animations[k]
-    ret = pbConvertAnimToNewFormat(animations[k])
-    count += 1 if ret
-  end
-  if count > 0
-    save_data(animations, "Data/PkmnAnimations.rxdata")
-    $game_temp.battle_animations_data = nil
-  end
-  pbMessage(_INTL("{1} animations converted to new format.", count))
 end

Data/Scripts/020_Debug/003_Debug menus/003_Debug_MenuExtraCode.rb

@@ -558,7 +558,7 @@ def pbExportAllAnimations
         safename = anim.name.gsub(/\W/, "_")
         Dir.mkdir("Animations/#{safename}") rescue nil
         File.open("Animations/#{safename}/#{safename}.anm", "wb") do |f|
-          f.write(dumpBase64Anim(anim))
+          f.write(BattleAnimationEditor.dumpBase64Anim(anim))
         end
         if anim.graphic && anim.graphic != ""
           graphicname = RTP.getImagePath("Graphics/Animations/" + anim.graphic)
@@ -626,13 +626,13 @@ def pbImportAllAnimations
         pbSafeCopyFile(image, RTP.getImagePath("Graphics/Animations/" + File.basename(image)), "Graphics/Animations/" + File.basename(image))
       end
       Dir.glob(folder + "/*.anm") do |f|
-        textdata = loadBase64Anim(IO.read(f)) rescue nil
+        textdata = BattleAnimationEditor.loadBase64Anim(IO.read(f)) rescue nil
         if textdata.is_a?(PBAnimation)
           index = pbAllocateAnimation(animations, textdata.name)
           missingFiles = []
           textdata.name = File.basename(folder) if textdata.name == ""
           textdata.id = -1   # This is not an RPG Maker XP animation
-          pbConvertAnimToNewFormat(textdata)
+          BattleAnimationEditor.pbConvertAnimToNewFormat(textdata)
           if textdata.graphic && textdata.graphic != "" &&
              !safeExists?(folder + "/" + textdata.graphic) &&
              !FileTest.image_exist?("Graphics/Animations/" + textdata.graphic)