avm-mays_magical_school 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13ba31a5611bc7137a52d3ab1b5629942621a8628f65a6e7a806338fa93e708f
+  data.tar.gz: '08c0a2bc2210b3ce10f1d74b0f42bacf55f38fd50ca356c4383212fbe6b64d13'
+SHA512:
+  metadata.gz: 8181c642214da510d093d65e2a27f48e1731d58e69ad93a11cc81eaf97b0da85b96e7c78821e84b400e49da81a7384f5f85030a40dc90b801976e9e6b10af10d
+  data.tar.gz: e9f23d6f1a42a6d50fb29080c0e8ac1996ed3812af4b7f01105511ed15479d35c8c32c150840985acb815a31a4804dd4e9aa156961d40b1310d6ed4fe16f9c7e

data/lib/avm/mays_magical_school/builders/assembly_stages/stage.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/mays_magical_school/builders/assembly_stages/terrain'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/bit_array'
+
+module Avm
+  module MaysMagicalSchool
+    module Builders
+      class AssemblyStages
+        class Stage
+          common_constructor :stages_data, :stage
+
+          def target_content
+            "stage_#{stage.number}:\n" \
+              '.byte ' + to_bit_array.to_byte_array.map(&:to_asm_hex).join(', ') + "\n"
+          end
+
+          def to_bit_array
+            r = ::EacRubyUtils::BitArray.new
+            terrains.each do |tile|
+              r.push_array(tile.to_bit_array)
+            end
+            r
+          end
+
+          private
+
+          def terrains
+            stage.terrains.map do |terrain|
+              ::Avm::MaysMagicalSchool::Builders::AssemblyStages::Terrain.new(self, terrain)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/builders/assembly_stages/terrain.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'cliutils/images/base'
+require 'cliutils/v2'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/bit_array'
+
+module Avm
+  module MaysMagicalSchool
+    module Builders
+      class AssemblyStages
+        class Terrain
+          BITS_PER_CODE = 6
+          BIT_RANGE = (0..BITS_PER_CODE - 1).freeze
+          CODE_RANGE = (0..(2**BITS_PER_CODE - 1)).freeze
+
+          common_constructor :stage, :terrain
+
+          def to_bit_array
+            ::EacRubyUtils::Byte.new(code).to_bit_array(BIT_RANGE)
+          end
+
+          def code
+            r = terrain.asm_code
+            return r if CODE_RANGE.include?(r)
+
+            raise ::RangeError, "Element: #{r}, Range: #{CODE_RANGE}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/builders/assembly_stages.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    module Builders
+      class AssemblyStages
+        require_sub __FILE__
+        enable_speaker
+        enable_simple_cache
+        common_constructor :source
+
+        def perform
+          infov 'Target file', target_file
+          target_file.write(target_content)
+        end
+
+        def target_file
+          source.path.join('res', 'stages.s')
+        end
+
+        def target_content
+          stages.map(&:target_content).join("\n")
+        end
+
+        def stages
+          source.stages.map do |stage|
+            ::Avm::MaysMagicalSchool::Builders::AssemblyStages::Stage.new(self, stage)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/builders/yaml_stages/stage.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/yaml'
+
+module Avm
+  module MaysMagicalSchool
+    module Builders
+      class YamlStages
+        class Stage
+          common_constructor :builder, :stage
+          delegate :source, :number, to: :stage
+
+          def perform
+            target_path.parent.mkpath
+            ::EacRubyUtils::Yaml.dump_file(target_path, target_data)
+          end
+
+          def target_data
+            {
+              objects: objects,
+              terrain: terrains_to_s
+            }
+          end
+
+          def target_path
+            builder.yaml_stages_dir.join("#{number}.yaml")
+          end
+
+          def terrains_to_s
+            stage.size.y.times.map { |y| terrains_row_to_s(y) + "\n" }.join
+          end
+
+          def objects
+            stage.objects.map do |obj|
+              { type: obj.type, x: obj.coord.x, y: obj.coord.y }
+            end
+          end
+
+          private
+
+          def terrains_row_to_s(terrains_y)
+            stage.size.x.times
+                 .map { |x| terrain_letter(stage.terrain(x, terrains_y)) }.join
+          end
+
+          def terrain_letter(terrain)
+            source.terrain_type_info.fetch_letter(terrain.type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/builders/yaml_stages.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'avm/mays_magical_school/printed_stage'
+require 'avm/mays_magical_school/terrain_type'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/fs/clearable_directory'
+
+module Avm
+  module MaysMagicalSchool
+    module Builders
+      class YamlStages
+        require_sub __FILE__
+        enable_simple_cache
+        enable_speaker
+        common_constructor :source
+
+        def perform
+          start_banner
+          source.stages.each do |stage|
+            ::Avm::MaysMagicalSchool::Builders::YamlStages::Stage.new(self, stage).perform
+          end
+        end
+
+        def start_banner
+          infov 'Source printscreens dir.', source.printed_stages_dir
+          infov 'Target YAML dir.', yaml_stages_dir
+          infov 'Terrain types', source.terrain_types.count
+          infov 'Stages', source.stages.count
+        end
+
+        def yaml_stages_dir
+          source.external_resources_dir.join('build', 'stages_yaml')
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/printed_stage/terrain.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'cliutils/v2'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class PrintedStage
+      class Terrain
+        SIZE = ::Cliutils.v2.new(16, 16)
+
+        enable_simple_cache
+        common_constructor :printed_stage, :coord
+        delegate :source, to: :printed_stage
+        delegate :object_type, :letter, :type, to: :terrain_type_version
+
+        private
+
+        def terrain_type_version_uncached
+          source.terrain_type_version(image)
+        end
+
+        def image
+          printed_stage.terrains_image.crop(coord * SIZE, SIZE)
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/printed_stage.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'avm/mays_magical_school/stage'
+require 'cliutils/images/base'
+require 'cliutils/v2'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class PrintedStage
+      require_sub __FILE__
+      enable_speaker
+      enable_simple_cache
+      common_constructor :source, :file
+
+      TERRAINS_OFFSET = ::Cliutils.v2.new(32, 23)
+      TERRAINS_COUNT = ::Cliutils.v2.new(11, 12)
+
+      # @return [Avm::MaysMagicalSchool::Stage]
+      def build_stage
+        ::Avm::MaysMagicalSchool::Stage.new(source, number, build_stage_terrain_types,
+                                            build_stage_objects)
+      end
+
+      def number
+        file.basename_noext.to_path.to_i
+      end
+
+      def terrains_flat
+        terrains.flat_map(&:itself)
+      end
+
+      def terrains_count
+        TERRAINS_COUNT
+      end
+
+      def terrain(*v2_args)
+        coord = ::Cliutils.v2.parse_args(*v2_args).first
+        terrains[coord.x][coord.y] || raise(::ArgumentError, "Index out of bounds: #{coord}")
+      end
+
+      private
+
+      def build_stage_objects
+        terrains_flat
+          .select { |t| t.object_type.present? }
+          .map { |t| ::Avm::MaysMagicalSchool::Stage::Object.new(t.object_type, t.coord) }
+      end
+
+      def build_stage_terrain_types
+        terrains_flat.map { |t| t.type.name.to_sym }
+      end
+
+      def image_uncached
+        ::Cliutils::Images::Base.from_file(file)
+      end
+
+      def terrains_image_uncached
+        image.crop(
+          TERRAINS_OFFSET,
+          TERRAINS_COUNT * ::Avm::MaysMagicalSchool::PrintedStage::Terrain::SIZE
+        )
+      end
+
+      # @return [Array<Array<Avm::MaysMagicalSchool::StagesBuilder::Terrain>>]
+      def terrains_uncached
+        TERRAINS_COUNT.x.times.map do |x|
+          TERRAINS_COUNT.y.times.map do |y|
+            ::Avm::MaysMagicalSchool::PrintedStage::Terrain
+              .new(self, ::Cliutils.v2.new(x, y))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/runner/extract_tiles.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require File.expand_path('ruby/init', ENV['MYSELF_LIB'])
+require 'cliutils/core_ext'
+require 'cliutils/core/command'
+require 'avm/mays_magical_school/sources/base'
+
+module Avm
+  module MaysMagicalSchool
+    class Runner
+      class ExtractTiles
+        runner_with :help do
+          desc 'Extrai tiles.'
+          bool_opt '-p', '--perform', 'Executa a extração de fato.'
+        end
+
+        def run
+          start_banner
+          original_tiles_sources.each(&:perform) if parsed.perform?
+        end
+
+        # @return [Pathname]
+        def original_tiles_root
+          source.external_resources_dir.join('src', 'snes_tiles')
+        end
+
+        # @return [Pathname]
+        def output_directory
+          source.external_resources_dir.join('build', 'snes_extracted_tiles')
+        end
+
+        private
+
+        def start_banner
+          infov 'Source', source
+          infov 'Original tiles root', original_tiles_root
+          infov 'Original tiles source', original_tiles_sources.count
+          infov 'Output directory', output_directory
+        end
+
+        def source_uncached
+          ::Avm::MaysMagicalSchool::Sources::Base.default
+        end
+
+        def original_tiles_sources_uncached
+          original_tiles_root.glob('*.png').map do |file|
+            OriginalTilesSource.new(self, file)
+          end
+        end
+
+        class OriginalTilesSource
+          common_constructor :runner, :source_file
+          delegate :source, to: :runner
+
+          def perform
+            extract_tiles_command.system!
+          end
+
+          def extract_tiles_command
+            ::Cliutils::Core.command('i/extract_tiles', '--width=16', '--height=16', '--output-dir',
+                                     output_dir,
+                                     source_file)
+          end
+
+          def output_dir
+            runner.output_directory.join(source_file.basename_noext)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/runner/tiles_plan.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'cliutils/core_ext'
+require 'avm/mays_magical_school/sources/base'
+require 'cliutils/nes/tiles_plan'
+
+module Avm
+  module MaysMagicalSchool
+    class Runner
+      class TilesPlan
+        runner_with :help do
+          desc 'Constrói os tiles para NES.'
+        end
+
+        def run
+          start_banner
+          tiles_plan.perform
+        end
+
+        private
+
+        def start_banner
+          infov 'App. instance', tiles_plan.app_instance
+          infov 'Source dir.', tiles_plan.source_dir
+          infov 'Target dir.', tiles_plan.target_dir
+        end
+
+        def app_instance
+          source
+        end
+
+        def tiles_plan_uncached
+          ::Cliutils::Nes::TilesPlan.new(
+            ::Cliutils::Paths.resource('eac/mays-magic-school_dev/tiles_plan.yaml'),
+            app_instance
+          )
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/runner/yaml_stages.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'cliutils/core_ext'
+require 'avm/mays_magical_school/builders/yaml_stages'
+
+module Avm
+  module MaysMagicalSchool
+    class Runner
+      class YamlStages
+        runner_with :help do
+          desc 'Constrói os arquivo de estágios em YAML.'
+        end
+
+        def run
+          source_banner
+          ::Avm::MaysMagicalSchool::Builders::YamlStages.new(source).perform
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/runner.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'cliutils/core_ext'
+require 'avm/mays_magical_school/sources/base'
+
+module Avm
+  module MaysMagicalSchool
+    class Runner
+      require_sub __FILE__
+      runner_with :help, :subcommands do
+        pos_arg :source_path
+        subcommands
+      end
+
+      def source_banner
+        infov 'AppSrc', source
+      end
+
+      def source_uncached
+        ::Avm::MaysMagicalSchool::Sources::Base.new(parsed.source_path)
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources/base/stage_builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/mays_magical_school/printed_stage'
+require 'avm/mays_magical_school/stage'
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      class Base < ::Avm::EacGenericBase0::Sources::Base
+        class StageBuilder
+          common_constructor :source, :number
+
+          # @return [Avm::MaysMagicalSchool::Stage, nil]
+          def build
+            build_from_cache || build_from_printed
+          end
+
+          private
+
+          # @return [Avm::MaysMagicalSchool::Stage, nil]
+          def build_from_cache
+            return nil unless fs_cache.stored?
+
+            ::Avm::MaysMagicalSchool::Stage.from_serialized_file(source, fs_cache.content_path)
+          end
+
+          def build_from_printed
+            printed_stage.if_present do |_v|
+              r = printed_stage.build_stage
+              r.serialize_file(fs_cache.content_path)
+              r
+            end
+          end
+
+          def fs_cache_parent
+            source.fs_cache.child('stages')
+          end
+
+          def fs_object_id
+            number.to_s
+          end
+
+          # @return [Avm::MaysMagicalSchool::Stage]
+          def printed_stage
+            source.printed_stages_dir.join("#{number}.png").if_exist do |v|
+              ::Avm::MaysMagicalSchool::PrintedStage.new(source, v)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources/base/stages.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      class Base < ::Avm::EacGenericBase0::Sources::Base
+        module Stages
+          STAGES_COUNT = 100
+
+          # @return [Pathname]
+          def printed_stages_dir
+            external_resources_dir.join('src', 'printed_stages')
+          end
+
+          private
+
+          # @return [Array<Avm::MaysMagicalSchool::Stage>]
+          def stages_uncached
+            STAGES_COUNT.times.map { |count| build_stage(count + 1) }.reject(&:blank?)
+          end
+
+          def build_stage(number)
+            ::Avm::MaysMagicalSchool::Sources::Base::StageBuilder.new(self, number).build
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources/base/terrain_types.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'eac_ruby_utils/core_ext'
+require 'avm/mays_magical_school/terrain_type_searcher'
+require 'avm/mays_magical_school/terrain_type_info'
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      class Base < ::Avm::EacGenericBase0::Sources::Base
+        module TerrainTypes
+          UNKNOWN_TYPE_TERRAIN_NAME = 'unknown'
+
+          def terrain_types_dir
+            external_resources_dir.join('src', 'stages_terrain_types')
+          end
+
+          def terrain_type_version(image)
+            ::Avm::MaysMagicalSchool::TerrainTypeSearcher.new(self, image).find
+          end
+
+          private
+
+          def terrain_types_uncached
+            terrain_types_dir.glob('*/').map do |dir|
+              ::Avm::MaysMagicalSchool::TerrainType.new(self, dir)
+            end
+          end
+
+          def terrain_type_info_uncached
+            ::Avm::MaysMagicalSchool::TerrainTypeInfo.new(self)
+          end
+
+          def unknown_terrain_type_uncached
+            terrain_types.find { |tt| tt.name == UNKNOWN_TYPE_TERRAIN_NAME } ||
+              raise("Terrain type not found with name \"#{UNKNOWN_TYPE_TERRAIN_NAME}\"")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'avm/mays_magical_school/sources/runners'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      class Base < ::Avm::EacGenericBase0::Sources::Base
+        require_sub __FILE__, include_modules: true
+        enable_simple_cache
+
+        DEFAULT_PATH_ENVVAR_KEY = 'MAYSMAGICSCHOOL_DEV_INSTALL_PATH'
+
+        class << self
+          def default
+            @default ||= new(ENV.fetch(DEFAULT_PATH_ENVVAR_KEY))
+          end
+        end
+
+        # @return [Pathname]
+        def external_resources_dir
+          instance.entry('resources_path').value.to_pathname
+        end
+
+        # @return [String]
+        def fs_object_id
+          path.to_path.variableize
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources/runners/assembly_stages.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'cliutils/core_ext'
+require 'avm/mays_magical_school/builders/assembly_stages'
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      module Runners
+        class AssemblyStages
+          runner_with :help do
+            desc 'Constrói o arquivo de estágios em Assembly.'
+          end
+
+          def run
+            source_banner
+            ::Avm::MaysMagicalSchool::Builders::AssemblyStages.new(runner_context.call(:source))
+                                                              .perform
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources/runners.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      module Runners
+        require_sub __FILE__
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/sources.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    module Sources
+      require_sub __FILE__
+    end
+  end
+end

data/lib/avm/mays_magical_school/stage/object.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class Stage
+      class Object
+        class << self
+          def from_serialized_data(data)
+            new(data.fetch(:type), ::Cliutils.v2.new(*data.fetch(:coord)))
+          end
+        end
+
+        common_constructor :type, :coord
+
+        def to_serialized_data
+          {
+            type: type, coord: coord.values
+          }
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/stage/terrain.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class Stage
+      class Terrain
+        common_constructor :stage, :type, :coord
+
+        def asm_code
+          stage.source.terrain_type_info.fetch_code(type)
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/stage.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'avm/eac_generic_base0/sources/base'
+require 'avm/mays_magical_school/builders/yaml_stages/stage'
+require 'cliutils/v2'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class Stage
+      require_sub __FILE__
+
+      SIZE = ::Cliutils.v2.new(11, 12)
+
+      class << self
+        def from_serialized_file(source, file)
+          from_serialized_data(source, ::EacRubyUtils::Yaml.load_file(file))
+        end
+
+        def from_serialized_data(source, data)
+          new(
+            source,
+            data.fetch(:number),
+            terrains_types_from_data(data.fetch(:terrains)),
+            objects_from_data(data.fetch(:objects))
+          )
+        end
+
+        private
+
+        def objects_from_data(data)
+          data.map.each do |item_data|
+            ::Avm::MaysMagicalSchool::Stage::Object.from_serialized_data(item_data)
+          end
+        end
+
+        def terrains_types_from_data(data)
+          data
+        end
+      end
+
+      attr_reader :source, :number, :terrains, :objects
+
+      def initialize(source, number, terrains_types, objects)
+        self.source = source
+        self.number = number
+        self.terrains = terrains_types.assert_count(SIZE.product, 'terrains_types')
+                                      .each_with_index.map do |tt, i|
+          ::Avm::MaysMagicalSchool::Stage::Terrain.new(self, tt, ::Cliutils.v2.new(
+                                                                   i % size.x,
+                                                                   i.div(size.y)
+                                                                 ))
+        end
+        self.objects = objects
+      end
+
+      def serialize_file(file)
+        file.to_pathname.parent.mkpath
+        ::EacRubyUtils::Yaml.dump_file(file, to_serialized_data)
+      end
+
+      def size
+        SIZE
+      end
+
+      def terrain(*coord_args)
+        coord = ::Cliutils.v2.new(*coord_args)
+        terrains.fetch(coord.x + coord.y * size.x)
+      end
+
+      def to_serialized_data
+        {
+          number: number,
+          terrains: terrains_to_serialized_data,
+          objects: objects_to_serialized_data
+        }
+      end
+
+      private
+
+      attr_writer :source, :number, :terrains, :objects
+
+      def objects_to_serialized_data
+        objects.map(&:to_serialized_data)
+      end
+
+      def terrains_to_serialized_data
+        terrains.map(&:type)
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/terrain_type/version.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'cliutils/v2'
+require 'cliutils/images/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class TerrainType
+      class Version
+        enable_simple_cache
+        common_constructor :type, :file
+        delegate :letter, to: :type
+
+        MAY_BASENAME = 'may'
+        FLAME_BASENAME = 'flame'
+
+        def match_image?(image)
+          self.image == image
+        end
+
+        private
+
+        def image_uncached
+          ::Cliutils::Images::Base.from_file(file)
+        end
+
+        def object_type_uncached
+          file.basename_noext.to_path.split('_').find { |s| !/\A\d+\z/.match?(s) }
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/terrain_type.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'cliutils/v2'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class TerrainType
+      require_sub __FILE__
+      enable_simple_cache
+      attr_reader :versions
+      common_constructor :source, :dir do
+        self.versions = dir.glob('*.png').map do |file|
+          ::Avm::MaysMagicalSchool::TerrainType::Version.new(self, file)
+        end
+      end
+
+      LETTER_FILE_BASENAME = 'letter'
+
+      def add(image)
+        path = new_image_file
+        path.parent.mkpath
+        image.write(path)
+        version = ::Avm::MaysMagicalSchool::TerrainType::Version.new(self, path)
+        versions << version
+        version
+      end
+
+      def new_image_file
+        i = 1
+        loop do
+          file = dir.join("#{i}.png")
+          return file unless file.exist?
+
+          i += 1
+        end
+      end
+
+      def letter
+        source.terrain_type_info.fetch_letter(name)
+      end
+
+      def match_image_version(image)
+        versions.find { |v| v.match_image?(image) }
+      end
+
+      def name
+        dir.basename.to_path
+      end
+
+      private
+
+      attr_writer :versions
+    end
+  end
+end

data/lib/avm/mays_magical_school/terrain_type_info/terrain_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class TerrainTypeInfo
+      class TerrainType
+        class << self
+          def from_data(info, data)
+            new(info, data.fetch(:name), data.fetch(:letter), data.fetch(:code))
+          end
+        end
+
+        common_constructor :info, :name, :letter, :code
+
+        def to_data
+          { name: name, letter: letter, code: code }
+        end
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/terrain_type_info.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class TerrainTypeInfo
+      require_sub __FILE__
+      attr_reader :terrain_types
+      common_constructor :source do
+        self.terrain_types = read_data_file.with_indifferent_access
+      end
+
+      NEW_LETTERS = [*'A'..'Z', *'a'..'z', *'0'..'9'].freeze
+
+      def fetch_code(terrain_type_name)
+        fetch_terrain(terrain_type_name).code
+      end
+
+      def fetch_letter(terrain_type_name)
+        fetch_terrain(terrain_type_name).letter
+      end
+
+      def fetch_terrain(terrain_type_name)
+        terrain_types[terrain_type_name] || new_terrain_type(terrain_type_name)
+      end
+
+      def file
+        source.terrain_types_dir.join('info.yaml')
+      end
+
+      private
+
+      attr_writer :terrain_types
+
+      def new_terrain_type(terrain_type_name)
+        terrain_types[terrain_type_name] = ::Avm::MaysMagicalSchool::TerrainTypeInfo::TerrainType
+                                           .new(self, terrain_type_name, new_terrain_type_letter,
+                                                new_terray_type_code)
+        write_data_file
+        terrain_types[terrain_type_name]
+      end
+
+      def new_terray_type_code
+        codes = terrain_types.values.map(&:code)
+        r = 0
+        r += 1 while codes.include?(r)
+        r
+      end
+
+      def new_terrain_type_letter
+        letters = terrain_types.values.map(&:letter)
+        NEW_LETTERS.each do |letter|
+          return letter unless letters.include?(letter)
+        end
+
+        raise 'No available letter'
+      end
+
+      def data_to_dump
+        terrain_types.values.map { |t| [t.name, t.to_data] }.sort_by { |v| [v.first] }
+                     .to_h.stringify_keys
+      end
+
+      def read_data_file
+        return {} unless file.exist?
+
+        ::EacRubyUtils::Yaml.load_file(file).map do |name, data|
+          [name, ::Avm::MaysMagicalSchool::TerrainTypeInfo::TerrainType.from_data(self, data)]
+        end.to_h
+      end
+
+      def write_data_file
+        ::EacRubyUtils::Yaml.dump_file(file, data_to_dump)
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/terrain_type_searcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'cliutils/v2'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    class TerrainTypeSearcher
+      require_sub __FILE__
+
+      common_constructor :source, :image
+
+      def find
+        find_by_known || find_by_unknown
+      end
+
+      private
+
+      def find_by_known
+        source.terrain_types.lazy.map { |tt| tt.match_image_version(image) }.find(&:present?)
+      end
+
+      def find_by_unknown
+        source.unknown_terrain_type.add(image)
+      end
+    end
+  end
+end

data/lib/avm/mays_magical_school/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Avm
+  module MaysMagicalSchool
+    VERSION = '0.2.0'
+  end
+end

data/lib/avm/mays_magical_school.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module MaysMagicalSchool
+    require_sub __FILE__
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: avm-mays_magical_school
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Put here the authors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: avm-eac_generic_base0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.112'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.112'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_gem_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/avm/mays_magical_school.rb
+- lib/avm/mays_magical_school/builders/assembly_stages.rb
+- lib/avm/mays_magical_school/builders/assembly_stages/stage.rb
+- lib/avm/mays_magical_school/builders/assembly_stages/terrain.rb
+- lib/avm/mays_magical_school/builders/yaml_stages.rb
+- lib/avm/mays_magical_school/builders/yaml_stages/stage.rb
+- lib/avm/mays_magical_school/printed_stage.rb
+- lib/avm/mays_magical_school/printed_stage/terrain.rb
+- lib/avm/mays_magical_school/runner.rb
+- lib/avm/mays_magical_school/runner/extract_tiles.rb
+- lib/avm/mays_magical_school/runner/tiles_plan.rb
+- lib/avm/mays_magical_school/runner/yaml_stages.rb
+- lib/avm/mays_magical_school/sources.rb
+- lib/avm/mays_magical_school/sources/base.rb
+- lib/avm/mays_magical_school/sources/base/stage_builder.rb
+- lib/avm/mays_magical_school/sources/base/stages.rb
+- lib/avm/mays_magical_school/sources/base/terrain_types.rb
+- lib/avm/mays_magical_school/sources/runners.rb
+- lib/avm/mays_magical_school/sources/runners/assembly_stages.rb
+- lib/avm/mays_magical_school/stage.rb
+- lib/avm/mays_magical_school/stage/object.rb
+- lib/avm/mays_magical_school/stage/terrain.rb
+- lib/avm/mays_magical_school/terrain_type.rb
+- lib/avm/mays_magical_school/terrain_type/version.rb
+- lib/avm/mays_magical_school/terrain_type_info.rb
+- lib/avm/mays_magical_school/terrain_type_info/terrain_type.rb
+- lib/avm/mays_magical_school/terrain_type_searcher.rb
+- lib/avm/mays_magical_school/version.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Put here de description.
+test_files: []