JumbledOutput (IEX2 - CustomStats)

class Game_Battler

        def base_maxcraft_en()
          return 200
        end

          def maxcraft_en()
            return [base_maxcraft_en + @maxcraft_en_plus, 1].max
          end

      def craft_en
        return @craft_en
      end

      def craft_en=( new_craft_en )
        @craft_en = [[new_craft_en, 0].max, maxcraft_en].min
      end

        STAT_INITS << "__initialize_craft_en"

        def __initialize_craft_en
          @maxcraft_en_plus = 0
          @craft_en = 0
        end

        def base_maxlink()
          return 3
        end

          def maxlink()
            n = base_maxlink + @maxlink_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxlink() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxlink()
        rts << sts.maxlink_rate() if sts.maxlink_rate() > 0
        r
      }

            return [n, 1].max
          end

      def link
        return @link
      end

      def link=( new_link )
        @link = [[new_link, 0].max, maxlink].min
      end

        STAT_INITS << "__initialize_link"

        def __initialize_link
          @maxlink_plus = 0
          @link = 0
        end

        def base_maxpheofeth()
          return 20
        end

          def maxpheofeth()
            n = base_maxpheofeth + @maxpheofeth_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxpheofeth() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxpheofeth()
        rts << sts.maxpheofeth_rate() if sts.maxpheofeth_rate() > 0
        r
      }

            return [n, 1].max
          end

      def pheofeth
        return @pheofeth
      end

      def pheofeth=( new_pheofeth )
        @pheofeth = [[new_pheofeth, 0].max, maxpheofeth].min
      end

        STAT_INITS << "__initialize_pheofeth"

        def __initialize_pheofeth
          @maxpheofeth_plus = 0
          @pheofeth = 0
        end

        def base_maxoverchge()
          return 5
        end

          def maxoverchge()
            n = base_maxoverchge + @maxoverchge_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxoverchge() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxoverchge()
        rts << sts.maxoverchge_rate() if sts.maxoverchge_rate() > 0
        r
      }

            return [n, 1].max
          end

      def overchge
        return @overchge
      end

      def overchge=( new_overchge )
        @overchge = [[new_overchge, 0].max, maxoverchge].min
      end

        STAT_INITS << "__initialize_overchge"

        def __initialize_overchge
          @maxoverchge_plus = 0
          @overchge = 0
        end

        def base_maxjavelin()
          return 6
        end

          def maxjavelin()
            n = base_maxjavelin + @maxjavelin_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxjavelin() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxjavelin()
        rts << sts.maxjavelin_rate() if sts.maxjavelin_rate() > 0
        r
      }

            return [n, 1].max
          end

      def javelin
        return @javelin
      end

      def javelin=( new_javelin )
        @javelin = [[new_javelin, 0].max, maxjavelin].min
      end

        STAT_INITS << "__initialize_javelin"

        def __initialize_javelin
          @maxjavelin_plus = 0
          @javelin = 0
        end

        def base_maxarounds()
          return 6
        end

          def maxarounds()
            n = base_maxarounds + @maxarounds_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxarounds() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxarounds()
        rts << sts.maxarounds_rate() if sts.maxarounds_rate() > 0
        r
      }

            return [n, 1].max
          end

      def arounds
        return @arounds
      end

      def arounds=( new_arounds )
        @arounds = [[new_arounds, 0].max, maxarounds].min
      end

        STAT_INITS << "__initialize_arounds"

        def __initialize_arounds
          @maxarounds_plus = 0
          @arounds = 0
        end

        def base_maxmagicdust()
          return 10
        end

          def maxmagicdust()
            n = base_maxmagicdust + @maxmagicdust_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxmagicdust() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxmagicdust()
        rts << sts.maxmagicdust_rate() if sts.maxmagicdust_rate() > 0
        r
      }

            return [n, 1].max
          end

      def magicdust
        return @magicdust
      end

      def magicdust=( new_magicdust )
        @magicdust = [[new_magicdust, 0].max, maxmagicdust].min
      end

        STAT_INITS << "__initialize_magicdust"

        def __initialize_magicdust
          @maxmagicdust_plus = 0
          @magicdust = 0
        end

        def base_maxbloodrive()
          return 15
        end

          def maxbloodrive()
            n = base_maxbloodrive + @maxbloodrive_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxbloodrive() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxbloodrive()
        rts << sts.maxbloodrive_rate() if sts.maxbloodrive_rate() > 0
        r
      }

            return [n, 1].max
          end

      def bloodrive
        return @bloodrive
      end

      def bloodrive=( new_bloodrive )
        @bloodrive = [[new_bloodrive, 0].max, maxbloodrive].min
      end

        STAT_INITS << "__initialize_bloodrive"

        def __initialize_bloodrive
          @maxbloodrive_plus = 0
          @bloodrive = 0
        end

        def base_maxplantpl()
          return 8
        end

          def maxplantpl()
            n = base_maxplantpl + @maxplantpl_plus
            n = equips.inject( n ) { |r, eq| r + eq.maxplantpl() }

      rts = []
      n = states.inject( n ) { |r, sts|
        r + sts.maxplantpl()
        rts << sts.maxplantpl_rate() if sts.maxplantpl_rate() > 0
        r
      }

            return [n, 1].max
          end

      def plantpl
        return @plantpl
      end

      def plantpl=( new_plantpl )
        @plantpl = [[new_plantpl, 0].max, maxplantpl].min
      end

        STAT_INITS << "__initialize_plantpl"

        def __initialize_plantpl
          @maxplantpl_plus = 0
          @plantpl = 0
        end

def __initialize_stats()
__initialize_craft_en()
__initialize_link()
__initialize_pheofeth()
__initialize_overchge()
__initialize_javelin()
__initialize_arounds()
__initialize_magicdust()
__initialize_bloodrive()
__initialize_plantpl()
end

 end