tyrano_dsl 0.1.0

data/lib/tyrano_dsl/elements_writers/title_screen_writer.rb

@@ -0,0 +1,87 @@
+require_relative '../file_actions/create_file'
+require_relative 'elements_writers_module'
+
+# Write the title screen
+class TyranoDsl::ElementsWriters::TitleScreenWriter
+
+  include TyranoDsl::ElementsWriters::ElementsWritersModule
+
+  # @param [TyranoDsl::Elements::World] world
+  # @return [Array]
+  def write(world)
+    log {'Writing title screen'}
+    background = get_background(world)
+    first_scene = get_first_scene(world)
+
+    content_text_content = title_screen_content(background, first_scene)
+    preload_text_content = preload_text([background.target_long_file_name])
+    [
+        TyranoDsl::FileActions::CreateFile.new(
+            File.join('data', 'scenario', "title_screen.ks"),
+            content_text_content
+        ),
+        TyranoDsl::FileActions::CreateFile.new(
+            File.join('data', 'scenario', 'system', "_title_screen.ks"),
+            preload_text_content
+        )
+
+    ]
+  end
+
+  private
+
+  # @param [TyranoDsl::Elements::Background] background
+  # @param [TyranoDsl::Elements::Scene] first_scene
+  def title_screen_content(background, first_scene)
+    <<HEREDOC
+[_tb_system_call storage=system/_title_screen.ks]
+
+[hidemenubutton]
+
+[tb_keyconfig  flag="0"  ]
+[tb_hide_message_window  ]
+[bg  storage="#{background.target_short_file_name}"  ]
+*title
+
+[glink  text="New&nbsp;Game"  x="600"  y="370"  target="*start"  ]
+[glink  text="Load&nbsp;Game"  x="600"  y="470"  target="*load"  ]
+[s  ]
+*start
+
+[showmenubutton]
+
+[cm  ]
+[tb_keyconfig  flag="1"  ]
+[jump  storage="#{first_scene.target_name}.ks"  target=""  ]
+[s  ]
+*load
+
+[cm  ]
+[showload]
+
+[jump  target="*title"  storage=""  ]
+[s  ]
+HEREDOC
+  end
+
+  # @param [TyranoDsl::Elements::World] world
+  # @return [TyranoDsl::Elements::Scene]
+  def get_first_scene(world)
+    first_scene_name = world.title_screen.first_scene_name
+    unless first_scene_name
+      raise TyranoDsl::TyranoException, 'No scene defined'
+    end
+    world.scenes[first_scene_name]
+  end
+
+  # @param [TyranoDsl::Elements::World] world
+  # @return [TyranoDsl::Elements::Background]
+  def get_background(world)
+    background_name = world.title_screen.background
+    unless background_name
+      raise TyranoDsl::TyranoException, 'No background defined for the title screen'
+    end
+    world.backgrounds[background_name]
+  end
+
+end

data/lib/tyrano_dsl/elements_writers/variables_writer.rb

@@ -0,0 +1,30 @@
+require_relative '../elements/variable'
+require_relative '../file_actions/json_patch'
+require_relative 'elements_writers_module'
+
+# Write a variable
+class TyranoDsl::ElementsWriters::VariablesWriter
+
+  include TyranoDsl::ElementsWriters::ElementsWritersModule
+
+  # @param [TyranoDsl::Elements::World] world
+  # @return [Array]
+  def write(world)
+    log {'Writing variables'}
+    variable_content = {}
+    world.variables.values.each do |variable|
+      variable_content[variable.target_name] = {
+          :val => variable.initial_value,
+          :kind => 'f'
+      }
+    end
+    [
+        TyranoDsl::FileActions::JsonPatch.new(
+            'builder_config.json',
+            ['map_var'],
+            variable_content
+        )
+    ]
+  end
+
+end

data/lib/tyrano_dsl/file_actions/clear_directory.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+require_relative 'files_actions_module'
+
+# Remove all files from a directory
+
+class TyranoDsl::FileActions::ClearDirectory
+
+  include TyranoDsl::FileActions::FileActionsModule
+
+  # @return [String]
+  attr_reader :path
+
+  # @param [String] path
+  def initialize(path)
+    @path = path
+    log {to_s}
+  end
+
+  # @param [String] tyrano_project_path
+  def run(tyrano_project_path)
+    full_path = File.join(tyrano_project_path, path)
+    log {"Cleaning [#{full_path}]"}
+    if File.exists? full_path
+      FileUtils.remove_entry full_path
+    end
+    FileUtils.mkdir_p full_path
+  end
+
+  def to_s
+    "Clear directory [#{path}]"
+  end
+
+end

data/lib/tyrano_dsl/file_actions/create_file.rb

@@ -0,0 +1,33 @@
+require_relative 'files_actions_module'
+
+# Create a file with a custom content
+class TyranoDsl::FileActions::CreateFile
+
+  include TyranoDsl::FileActions::FileActionsModule
+
+  # @return [String]
+  attr_reader :content
+  # @return [String]
+  attr_reader :path
+
+  # @param [String] path
+  # @param [String] content
+  def initialize(path, content)
+    @path = path
+    @content = content
+    log {self.to_s}
+  end
+
+  # @param [String] tyrano_project_path
+  def run(tyrano_project_path)
+    full_path = File.join(tyrano_project_path, path)
+    log {"Creating file [#{full_path}]"}
+    create_parent_dir_if_not_exist(full_path)
+    File.write(full_path, content)
+  end
+
+  def to_s
+    "Create file [#{path}]"
+  end
+
+end

data/lib/tyrano_dsl/file_actions/file_copy.rb

@@ -0,0 +1,36 @@
+require 'fileutils'
+
+require_relative 'files_actions_module'
+
+
+# Direct copy of a file from a source to a destination
+class TyranoDsl::FileActions::FileCopy
+
+  # @return [String]
+  attr_reader :from_path
+  # @return [String]
+  attr_reader :to_path
+
+  include TyranoDsl::FileActions::FileActionsModule
+
+  # @param [String] from_path
+  # @param [String] to_path
+  def initialize(from_path, to_path)
+    @from_path = from_path
+    @to_path = to_path
+    log {self.to_s}
+  end
+
+  # @param [String] tyrano_project_path
+  def run(tyrano_project_path)
+    full_path = File.join(tyrano_project_path, to_path)
+    log {"Copy file [#{from_path}] to [#{full_path}]"}
+    create_parent_dir_if_not_exist(full_path)
+    FileUtils.copy_file from_path, full_path
+  end
+
+  def to_s
+    "Copy file [#{from_path}] to [#{to_path}]"
+  end
+
+end

data/lib/tyrano_dsl/file_actions/files_actions_module.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+module TyranoDsl
+  module FileActions
+
+    # Helpers to write file actions
+    module FileActionsModule
+
+      protected
+
+      def create_parent_dir_if_not_exist(file_path)
+        parent_dir = File.dirname(file_path)
+        unless File.exists? parent_dir
+          FileUtils.mkdir_p parent_dir
+        end
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def log
+        logger.info(self.class) {yield}
+      end
+
+    end
+  end
+end

data/lib/tyrano_dsl/file_actions/json_patch.rb

@@ -0,0 +1,47 @@
+require 'json'
+
+require_relative 'files_actions_module'
+
+# Path a JSON file
+class TyranoDsl::FileActions::JsonPatch
+
+  include TyranoDsl::FileActions::FileActionsModule
+
+  # @return [String]
+  attr_reader :file_path
+  # @return [Object]
+  attr_reader :patched_content
+  # @return [Array<String>]
+  attr_reader :patching_path
+
+  # @param [String] file_path
+  # @param [Array<String>] patching_path
+  # @param [Object] patched_content
+  def initialize(file_path, patching_path, patched_content)
+    @file_path = file_path
+    @patching_path = patching_path
+    @patched_content = patched_content
+    log {self.to_s}
+  end
+
+  # @param [String] tyrano_project_path
+  def run(tyrano_project_path)
+    full_path = File.join(tyrano_project_path, file_path)
+    log {"Patching file [#{full_path}] at #{patching_path}"}
+    unless File.exist? full_path
+      raise TyranoDsl::TyranoException, "Missing file [#{full_path}]"
+    end
+    content = JSON.parse(IO.read(full_path))
+    current_subtree = content
+    0.upto(patching_path.length - 2) do |path_segment_index|
+      current_subtree = current_subtree[patching_path[path_segment_index]]
+    end
+    current_subtree[patching_path.last] = patched_content
+    File.write(full_path, JSON.pretty_generate(content))
+  end
+
+  def to_s
+    "Patch JSON [#{file_path}] at #{patching_path}"
+  end
+
+end

data/lib/tyrano_dsl/main.rb

@@ -0,0 +1,18 @@
+require_relative 'parser'
+require_relative 'parsing_context'
+require_relative 'tyrano_exception'
+require_relative 'tyrano_dsl'
+require_relative 'writer'
+
+class TyranoDsl::Main
+
+  # @param [String] file_path path to the DSL file
+  # @return [TyranoDsl::WritingContext]
+  def run(file_path)
+    parsing_context = TyranoDsl::ParsingContext.new
+    parser = TyranoDsl::Parser.new(parsing_context, file_path)
+    parser.include_file(file_path)
+    TyranoDsl::Writer.new.write(parsing_context.world, parsing_context.words)
+  end
+
+end

data/lib/tyrano_dsl/parsed_word.rb

@@ -0,0 +1,22 @@
+require_relative 'tyrano_dsl'
+
+# A parsed word
+class TyranoDsl::ParsedWord
+
+  # @return [Hash]
+  attr_reader :parameters
+  # @return [String]
+  attr_reader :word
+  # @return [Array<String>]
+  attr_reader :word_location
+
+  # @param [String] word
+  # @param [Array<String>] word_location
+  # @param [Hash] parameters
+  def initialize(word, word_location, parameters)
+    @word = word
+    @word_location = word_location
+    @parameters = parameters
+  end
+
+end

data/lib/tyrano_dsl/parser.rb

@@ -0,0 +1,58 @@
+require 'logger'
+
+require_relative 'parsed_word'
+require_relative 'tyrano_exception'
+require_relative 'tyrano_dsl'
+require_relative 'vocabulary'
+
+# Parse the DSL
+class TyranoDsl::Parser
+
+  # @return [TyranoDsl::ParsingContext]
+  attr_reader :context
+  # @return [Array<String>]
+  attr_accessor :word_location
+  # @return [Array<String>]
+  attr_reader :included_files_hierarchy
+
+  TyranoDsl::Vocabulary.get_words_class('parsing_words') do |word, word_module|
+    include word_module
+
+    # Patch the method to store the location when a word is called
+    symbol_word = word.to_sym
+    old_method = instance_method(symbol_word)
+    define_method(symbol_word) do |*args|
+      self.word_location = caller
+      old_method.bind(self).call(*args)
+    end
+  end
+
+  # @param [TyranoDsl::ParsingContext] parsing_context
+  # @param [String] initial_file_path
+  def initialize(parsing_context, initial_file_path)
+    @context = parsing_context
+    @logger = Logger.new(STDOUT)
+    @included_files_hierarchy = [initial_file_path]
+  end
+
+  protected
+
+  # Add a parsed word
+  # @param [String] word
+  # @param [Hash{String => Object}] parameters
+  # @return [void]
+  def add_parsed_word(word, parameters = {})
+    context.words << TyranoDsl::ParsedWord.new(
+        word,
+        word_location,
+        parameters
+    )
+  end
+
+  private
+
+  def log
+    @logger.info(self.class) {yield}
+  end
+
+end

data/lib/tyrano_dsl/parsing_context.rb

@@ -0,0 +1,18 @@
+require_relative 'elements/world'
+require_relative 'parsed_word'
+require_relative 'tyrano_dsl'
+
+# Context for parsing, used by words to store content
+class TyranoDsl::ParsingContext
+
+  # @return [Array<TyranoDsl::ParsedWord>]
+  attr_reader :words
+  # @return [TyranoDsl::Elements::World]
+  attr_reader :world
+
+  def initialize
+    @words = []
+    @world = TyranoDsl::Elements::World.new
+  end
+
+end

data/lib/tyrano_dsl/parsing_words/ask_question.rb

@@ -0,0 +1,32 @@
+require_relative '../vocabulary'
+require_relative 'parsing_words_module'
+module TyranoDsl::ParsingWords::AskQuestion
+
+  include TyranoDsl::ParsingWords::ParsingWordsModule
+
+  # @return [void]
+  # @raise [TyranoDsl::TyranoException]
+  # @param [Hash{String=>Hash\nil}] possible_answers
+  def ask_question(possible_answers)
+    symbolized_possible_answers = possible_answers.collect do |possible_answer|
+      unless possible_answer.is_a? Hash
+        raise TyranoDsl::TyranoException, 'Parameter is not a Hash'
+      end
+      symbolized_possible_answer = symbolize_keys(possible_answer)
+      [:text, :left, :top, :scene].each do |param_name|
+        unless symbolized_possible_answer.key? param_name
+          raise TyranoDsl::TyranoException, "Missing value for #{param_name}"
+        end
+      end
+      scene = symbolized_possible_answer[:scene]
+      label = symbolized_possible_answer[:label]
+      context.world.jump_targets << TyranoDsl::Elements::JumpTarget.new(scene, label ? context.world.label_value(label) : nil)
+      symbolized_possible_answer
+    end
+    add_parsed_word(
+        TyranoDsl::Vocabulary::ASK_QUESTION,
+        possible_answers: symbolized_possible_answers
+    )
+  end
+
+end