aromancer 0.0.6 → 0.0.8

data/lib/aromancer/routes.rb

@@ -13,6 +13,8 @@
 module Aromancer
   class Routes
 
+    WIDTH_MULTIPLIER = TTY::Screen.width / 4.0
+
     def self.resume
       return main_menu if Aromancer::Storage.get_signed_out_flag
 
@@ -28,12 +30,7 @@ module Aromancer
         rescue ArgumentError => e
           authentication
         end
-        return
       end
-
-      legend_menu if !active_legend.nil? &&
-        (Aromancer::Storage.get_player && Aromancer::Storage.get_player&.symbolize_keys[:active_legend_id])
-      authentication
     end
 
     def self.cls
@@ -49,25 +46,10 @@ module Aromancer
       ).first
     end
 
-    def self.arena_data
-      arena = Aromancer::Storage.get_arena
-      if arena.nil?
-        Aromancer::Api.load_arena
-        sleep(1)
-      end
-
-      if arena.nil?
-        Aromancer.print_last_error("routes.legend.arena_failed")
-        Aromancer::Api.set_active_legend_id(nil)
-        Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
-        main_menu
-      else
-        arena
-      end
-    end
-
     def self.authentication
-      if Aromancer::Storage.get_player
+      unless Aromancer::Storage.get_player.nil? ||
+        Aromancer::Storage.get_player["api_key"].nil?
+
         Aromancer::Storage.set_signed_out_flag(false)
         return main_menu
       end
@@ -91,6 +73,9 @@ module Aromancer
         }},
         {value: :configure, proc: Proc.new{
           configure
+        }},
+        {value: :exit, proc: Proc.new{
+          exit
         }}
       ]
       Thread.main[:route] = __method__.to_sym
@@ -98,7 +83,7 @@ module Aromancer
 
     def self.configure
       cls
-
+      Aromancer.print_large_text(Thread.main[:route].to_s)
       Aromancer::Prompt.say(I18n.t("routes.configure.title", name: Aromancer.to_s.downcase))
       [
         Aromancer::Storage.get_server_url,
@@ -182,6 +167,20 @@ module Aromancer
       Thread.main[:route] = __method__.to_sym
     end
 
+    def self.rules
+      return if Thread.main[:route] == __method__.to_sym
+      rules = Aromancer::Api.load_rules
+      Aromancer::Prompt.say(rules["rules"], ljust: true)
+
+      Thread.main[:menu_options][__method__.to_sym] = [
+        {name: I18n.t("shared.key_press"), value: :key_press}
+      ]
+      Thread.main[:menu_runners][__method__.to_sym] = [
+        {value: :key_press, proc: Proc.new{ main_menu }}
+      ]
+      Thread.main[:route] = __method__.to_sym
+    end
+
     def self.main_menu
       cls
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :main_menu)) if Aromancer::Storage.get_preference(:debug)
@@ -200,10 +199,12 @@ module Aromancer
 
       return authentication if player.nil?
 
+      Aromancer.print_large_text
       Thread.main[:menu_options][__method__.to_sym] ||= [
         {name: I18n.t("routes.main_menu.new_game"), value: :new},
         {name: I18n.t("routes.main_menu.load_game"), value: :load},
         {name: I18n.t("routes.main_menu.find_game"), value: :find},
+        {name: I18n.t("routes.main_menu.rules"), value: :rules},
         {name: I18n.t("routes.main_menu.configure"), value: :configure},
         {name: I18n.t("routes.main_menu.sign_out"), value: :out},
         {name: I18n.t("shared.exit"), value: :exit}
@@ -227,6 +228,9 @@ module Aromancer
         {value: :configure, proc: Proc.new{
           configure
         }},
+        {value: :rules, proc: Proc.new{
+          rules
+        }},
         {value: :out, proc: Proc.new{
           case Aromancer::Prompt.p.select(I18n.t("shared.confirm"), [:no, :yes], cycle: true, per_page: 11)
           when :no
@@ -235,6 +239,9 @@ module Aromancer
             Aromancer::Api.sign_out
             authentication
           end
+        }},
+        {value: :exit, proc: Proc.new{
+          exit
         }}
       ]
       Thread.main[:route] = __method__.to_sym
@@ -260,18 +267,8 @@ module Aromancer
       ]
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :continue, proc: Proc.new{
-          Aromancer::Storage.instance.clear_cache!
           Aromancer::Api.create_legend(params)
           legend_menu
-          # Aromancer::Api.get_legends
-
-          # unless active_legend.nil? || active_legend["id"] != Aromancer::Storage.get_player["active_legend_id"]
-          #   Aromancer.print_last_error
-          #   sleep(1)
-          #   main_menu
-          # else
-          #   legend_menu
-          # end
         }},
         {value: :cancel, proc: Proc.new{
           Aromancer::Prompt.say(I18n.t("routes.new_game.cancelled"))
@@ -289,7 +286,6 @@ module Aromancer
 
       # if legend_array.nil?, load player's legends
       if legend_array.nil?
-        Aromancer::Storage.instance.clear_cache!
         Aromancer::Api.get_legends
         legend_array = Aromancer::Storage.get_legends
         unless legend_array.any?
@@ -301,7 +297,7 @@ module Aromancer
 
       Thread.main[:menu_options][__method__.to_sym] = [{name: I18n.t("shared.back"), value: :back}] + legend_array.map{|l|
         {
-          name: "#{I18n.t("routes.legend.title")}_#{l["id"]} (#{l["status"]}) #{DateTime.parse(l["created_at"])&.strftime(Aromancer::Api::DATE_FORMAT)}",
+          name: "#{l["value_display"]} > #{l["status"]} > #{Aromancer.date_display(l["created_at"])}",
           value: l["id"]
         }
       }
@@ -311,39 +307,37 @@ module Aromancer
       end
 
       Thread.main[:menu_runners][__method__.to_sym] = [
-        {value: :back, proc: Proc.new{ main_menu }},
+        {value: :back, proc: Proc.new{
+          Aromancer::Api.set_active_legend_id(nil)
+          main_menu
+        }},
       ] + legend_array.map{|l|
         {
           value: l["id"],
           proc: Proc.new{
             Aromancer::Api.set_active_legend_id(l["id"])
+            sleep(1)
+            Aromancer::Api.get_legends
 
-            unless active_legend.nil? || active_legend["id"] != Aromancer::Storage.get_player["active_legend_id"]
-              Aromancer.print_last_error
-              sleep(1)
-              main_menu
-            else
-              legend_menu
-            end
+            legend_menu
           }
         }
       }
       Thread.main[:route] = __method__.to_sym
     end
 
-    def self.stream
-      Aromancer::Api.load_stream
+    def self.stream(display_only: false, recent_count: nil)
+      return if Thread.main[:route] == __method__.to_sym
+      Aromancer::Prompt.print_divider(I18n.t("routes.stream.title"))
+      Aromancer::Api.load_stream(recent_count)
       stream = Aromancer::Storage.get_stream
-      Aromancer::Prompt.say(I18n.t("routes.stream.title"))
-      Aromancer::Prompt.say([
-        :timestamp,
-        :description
-      ].join(", "))
-
-      stream["stream"].each{|e|
-        Aromancer::Prompt.say("\n")
-        Aromancer::Prompt.say([e["updated_at"], e["description"]].join("\n"))
+      stream["stream"].last(
+        recent_count.nil? ? stream["stream"].count : recent_count
+      ).each{|e|
+        Aromancer::Prompt.say("[#{Aromancer.time_display(e["updated_at"])}]: #{e["description"]}", ljust: true)
       }
+      Aromancer::Prompt.print_divider(I18n.t("routes.stream.end"))
+      return if display_only
 
       Thread.main[:menu_options][__method__.to_sym] ||= [{name: I18n.t("shared.key_press"), value: nil}]
       Thread.main[:menu_runners][__method__.to_sym] ||= [
@@ -354,52 +348,93 @@ module Aromancer
 
     def self.legend_menu
       cls
-      legend
-
-      legend_array = Aromancer::Storage.get_legends
       al = active_legend
-      if !al.nil?
-        if al["status"] == "complete"
-          Aromancer::Api.set_active_legend_id(nil)
-          Aromancer::Prompt.say(I18n.t("routes.legend.legend_complete"))
-          return legends
-        elsif al["status"] == "created"
+      al_status = ((al || {})["status"] || "").to_sym
+      arena = Aromancer::Storage.get_arena
+      if !al_status.nil? &&
+        ![:started, :paused].include?(al_status) &&
+        !al.nil? &&
+        !arena.nil?
+
+        stream(display_only: true) # display entire stream
+        Aromancer::Prompt.print_divider(al["value_display"])
+        Aromancer::Prompt.say(arena["title"])
+        Aromancer::Prompt.say(arena["players"].map{|p| "#{p["alias"]}(#{p["status"]}): #{p["score"]}"}.join(" | "))
+        Thread.main[:route] = __method__.to_sym
+        case al_status
+        when :created
+          Aromancer::Api.get_legends
+
+          Thread.main[:menu_options][__method__.to_sym] = [
+            {name: I18n.t("shared.key_press"), value: :key_press}
+          ]
+          Thread.main[:menu_runners][__method__.to_sym] = [
+            {value: :key_press, proc: Proc.new{
+              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_", route: :legends))
+              Aromancer::Api.set_active_legend_id(nil)
+              sleep(1)
+              legends
+            }}
+          ]
+        when :complete
           Thread.main[:menu_options][__method__.to_sym] = [
-            {name: :reload, value: :reload}, {name: I18n.t("shared.back"), value: :back}
+            {name: I18n.t("shared.key_press"), value: :key_press}
           ]
-          Thread.main[:menu_runners][__method__.to_sym] ||= [
-            {value: :reload, proc: Proc.new{ legend_menu }},
-            {value: :back, proc: Proc.new{
+          Thread.main[:menu_runners][__method__.to_sym] = [
+            {value: :key_press, proc: Proc.new{
+              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_", route: :legends))
               Aromancer::Api.set_active_legend_id(nil)
-              main_menu
+              legends
             }}
           ]
-          Thread.main[:route] = __method__.to_sym
-          return
         end
+        return
+      end
+
+      arena = Aromancer::Storage.get_arena
+      if arena.nil? || arena["turn_player"].nil?
+        Aromancer::Prompt.say(I18n.t("shared.waiting"))
+        Thread.main[:menu_options][__method__.to_sym] = []
+        Thread.main[:menu_runners][__method__.to_sym] = []
+        sleep(1)
+        Aromancer::Api.get_legends
+        Aromancer::Api.load_arena
+        return
       end
-      hs = Aromancer::Storage.get_preference(:hide_sentences)
-      hs_value = "#{hs ? "" : "hide_"}signed_sentences".to_sym
+
+      legend
 
       Thread.main[:route] = __method__.to_sym
+
+      hide_sentences_pref = Aromancer::Storage.get_preference(:hide_sentences)
+      hide_sentences_pref_value = "#{hide_sentences_pref ? "" : "hide_"}signed_sentences".to_sym
+      hide_stream_pref = Aromancer::Storage.get_preference(:hide_stream)
+      hide_stream_pref_value = "#{hide_stream_pref ? "" : "hide_"}title".to_sym
       Thread.main[:menu_options][__method__.to_sym] = [
-        {name: I18n.t("routes.legend.unspoken_words"), value: :words},
-        {name: I18n.t("routes.legend.spoken_words"), value: :spoken_words},
-        {name: I18n.t("routes.legend.unsigned_sentences"), value: :unsigned_sentences},
-        {name: I18n.t("routes.legend.#{hs_value}"), value: hs_value},
-        {name: I18n.t("routes.stream.title"), value: :stream},
+        {name: I18n.t("routes.legend.#{hide_sentences_pref_value}"), value: hide_sentences_pref_value},
+        {name: I18n.t("routes.stream.#{hide_stream_pref_value}"), value: hide_stream_pref_value},
         {name: I18n.t("routes.main_menu.title"), value: :main_menu}
       ]
+      if arena["turn_player"]["id"] == Aromancer::Storage.get_player["id"]
+        [
+          {name: I18n.t("routes.legend.unspoken_words"), value: :words},
+          {name: I18n.t("routes.legend.spoken_words"), value: :spoken_words},
+          {name: I18n.t("routes.legend.unsigned_sentences"), value: :unsigned_sentences}
+        ].reverse.each{|mo| Thread.main[:menu_options][__method__.to_sym].insert(0, mo)}
+      end
 
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :words, proc: Proc.new{ words }},
         {value: :spoken_words, proc: Proc.new{ spoken_words }},
         {value: :unsigned_sentences, proc: Proc.new{ unsigned_sentences }},
-        {value: hs_value, proc: Proc.new{
+        {value: hide_sentences_pref_value, proc: Proc.new{
           Aromancer::Storage.toggle_preference(:hide_sentences)
           legend_menu
         }},
-        {value: :stream, proc: Proc.new{ stream }},
+        {value: hide_stream_pref_value, proc: Proc.new{
+          Aromancer::Storage.toggle_preference(:hide_stream)
+          legend_menu
+        }},
         {value: :main_menu, proc: Proc.new{
           Aromancer::Api.set_active_legend_id(nil)
           main_menu
@@ -409,60 +444,34 @@ module Aromancer
 
     def self.legend
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :legend)) if Aromancer::Storage.get_preference(:debug)
-      Aromancer::Api.load_arena
-      arena = arena_data
-      al = active_legend
-      al_status = ((al || {})["status"] || "").to_sym
-      if !al.nil? &&
-        [:created, :complete].include?(al_status)
-        Aromancer::Prompt.say(arena["title"])
-        Aromancer::Prompt.say(I18n.t("routes.legend.title"))
-        Aromancer::Prompt.say(I18n.t("routes.legend.subtitle", subtitle: al["status"]))
-        Aromancer::Prompt.say(I18n.t("routes.legend.players"))
-        Aromancer::Prompt.say(JSON.pretty_generate(arena["players"]))
-        Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
-        if al_status == :complete
-          Aromancer::Api.set_active_legend_id(nil)
-          sleep(1)
-          return main_menu
-        else
-          Aromancer::Api.get_legends
-          legend_menu
-        end
-      end
-
+      arena = Aromancer::Storage.get_arena
       return if arena.nil? || arena["turn_player"].nil?
 
-      # todo: pre-calculate needed widths. this isn't really working
-      word_width = 5.0
-      wpr = (TTY::Screen.width / word_width).floor
-
-      # puts "wpr: #{wpr}"
-      # puts TTY::Screen.width
-
       turn_player = arena["turn_player"]
 
       # title
-      Aromancer::Prompt.say("\n\n")
-      data = [
-        [arena["title"]],
-        ["#{turn_player["alias"]}'s turn"],
-        ["dealer is #{arena["dealer"]["alias"]}"]
-      ]
-      title_table = TTY::Table.new(data)
-      Aromancer::Prompt.say(title_table.render(:ascii))
-
-      # players
-      data = [
-        [I18n.t("routes.legend.players")] + arena["players"].map{|p| "#{p["alias"]} (#{p["score"]})"}
-      ]
-      players_table = TTY::Table.new(data)
-      Aromancer::Prompt.say(players_table.render(:ascii))
+      Aromancer::Prompt.say("\n")
+      ([
+          "#{I18n.t("routes.legend.title")}: #{(active_legend || {})["value_display"]}",
+          "#{arena["title"]}: #{turn_player["alias"]}'s turn. dealer is #{arena["dealer"]["alias"]}"
+        ] + arena["players"].map{|p| "#{p["alias"].rjust(11)} (#{p["score"]})"}
+      ).each{|l| Aromancer::Prompt.say(l, rjust: true)}
+
+      if !arena["bot_player"].nil?
+        # todo: show/hide preference
+        render_alchemy_for(arena["bot_player"])
+      end
+      render_scroll(arena)
+      render_alchemy_for(arena["player"])
+    end
 
+    # todo: move this to helper class. not a route
+    def self.render_scroll(arena)
+      Aromancer::Prompt.print_divider(I18n.t("routes.legend.scroll"))
       # spoken words
       Aromancer::Prompt.say(I18n.t("routes.legend.spoken_words"))
-
-      data = arena["scroll_words"].map{|sw| sw["value_display"]}.each_slice(wpr).to_a || []
+      Aromancer::Prompt.say("\n")
+      data = arena["scroll_words"].map{|sw| sw["value_display"]}.each_slice(Aromancer::Routes::WIDTH_MULTIPLIER).to_a || []
       while data.any? && data.last.length < data.first.length
         data.last << ""
       end
@@ -472,34 +481,52 @@ module Aromancer
       unless arena["sentences"].empty?
         # unsigned sentences
         Aromancer::Prompt.say(I18n.t("routes.legend.unsigned_sentences"))
-        data = arena["sentences"].map{|sw| sw["value_display"]}.each_slice(wpr).to_a || []
+        Aromancer::Prompt.say("\n")
+        data = arena["sentences"].map{|sw| sw["value_display"]}.each_slice(Aromancer::Routes::WIDTH_MULTIPLIER).to_a || []
         while data.any? && data.last.length < data.first.length
           data.last << ""
         end
         unsigned_sentences_table = TTY::Table.new(data)
-        Aromancer::Prompt.say(unsigned_sentences_table.render(:unicode))
+        Aromancer::Prompt.say(unsigned_sentences_table.render)
       end
+    end
 
+    # todo: move this to helper class. not a route
+    def self.render_alchemy_for(player)
       # unspoken words
+      if player["id"].to_i != Aromancer::Storage.get_player["id"].to_i
+        Aromancer::Prompt.print_divider(I18n.t("routes.legend.alchemy_for", name: player["alias"]))
+      else
+        Aromancer::Prompt.print_divider(I18n.t("routes.legend.your_alchemy"))
+      end
       Aromancer::Prompt.say(I18n.t("routes.legend.unspoken_words"))
-      data = arena["player"]["words"].map{|w| w["value_display"]}.each_slice(wpr).to_a || []
+      Aromancer::Prompt.say("\n\n")
+      words = player["words"].map{|w| w["value_display"]}
+      data = words.each_slice(Aromancer::Routes::WIDTH_MULTIPLIER).to_a || []
       while data.any? && data.last.length < data.first.length
         data.last << ""
       end
       words_table = TTY::Table.new(data)
       Aromancer::Prompt.say(words_table.render(:ascii))
 
-      unless arena["player"]["sentences"].empty?
+      unless player["sentences"].empty?
         # signed sentences
-        Aromancer::Prompt.say("#{I18n.t("routes.legend.signed_sentences")} (#{arena["player"]["sentences"].length})")
+        Aromancer::Prompt.say("#{I18n.t("routes.legend.signed_sentences")} (#{player["sentences"].length})")
         unless Aromancer::Storage.get_preference(:hide_sentences)
-          data = arena["player"]["sentences"].map{|s| s["value_display"]}.each_slice(wpr).to_a || []
+          data = player["sentences"].map{|s| s["value_display"]}.each_slice(Aromancer::Routes::WIDTH_MULTIPLIER).to_a || []
           while data.any? && data.last.length < data.first.length
             data.last << ""
           end
           sentences_table = TTY::Table.new(data)
-          Aromancer::Prompt.say(sentences_table.render(:ascii))
+          Aromancer::Prompt.say(sentences_table.render)
         end
+        Aromancer::Prompt.say("\n\n")
+      end
+
+      unless player["id"].to_i != Aromancer::Storage.get_player["id"].to_i ||
+        Aromancer::Storage.get_preference(:hide_stream)
+
+        stream(display_only: true, recent_count: 5)
       end
     end
 
@@ -507,7 +534,12 @@ module Aromancer
       cls
       legend
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
+      if arena["player"].nil? || arena["player"]["words"].nil?
+        Aromancer::Api.load_arena
+        sleep(1)
+        main_menu
+      end
       Thread.main[:menu_options][__method__.to_sym] = [
         {name: I18n.t("shared.back"), value: :back}
       ] + arena["player"]["words"].map{|w| {name: w["value_display"], value: w["id"]}}
@@ -526,7 +558,7 @@ module Aromancer
       cls
       legend
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
       Thread.main[:menu_options][__method__.to_sym] = [
         {name: I18n.t("shared.back"), value: :back}
       ] + arena["scroll_words"].map{|w| {name: w["value_display"], value: w["id"]}}
@@ -545,10 +577,10 @@ module Aromancer
       cls
       legend
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
       Thread.main[:menu_options][__method__.to_sym] = [
         {name: I18n.t("shared.back"), value: :back}
-      ] + arena["sentences"].map{|s| {name: "id: #{s["id"]}, value: #{s["value"]}", value: s["id"]}}
+      ] + arena["sentences"].map{|s| {name: s["value_display"], value: s["id"]}}
 
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :back, proc: Proc.new{ legend_menu }}
@@ -566,7 +598,7 @@ module Aromancer
 
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :word)) if Aromancer::Storage.get_preference(:debug)
       possibilities = Aromancer::Api.load_word_possibilities(selected_word_id)
-
+      request_uuid = possibilities["uuid"]
       if Aromancer::Storage.get_preference(:debug)
         Aromancer::Prompt.say(JSON.pretty_generate(possibilities))
       end
@@ -575,11 +607,12 @@ module Aromancer
       selected_word = possibilities["word"]
       for_type = possibilities["for_type"].to_sym
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
       player_words = arena["player"]["words"]
 
       choices = [{name: I18n.t("shared.back"), value: :back}]
-      if for_type == :player_word
+      if for_type == :player_word &&
+        arena["turn_player"]["id"] == Aromancer::Storage.get_player["id"]
 
         # show place on scroll option if selected word is from player's words
         choices << {
@@ -588,8 +621,11 @@ module Aromancer
         }
       end
 
-      choices += options.map{|o| {name: "#{o["humanized_title"]} -> weight: #{o["total_weight"]}", value: o}}
+      unless arena["turn_player"]["id"] != Aromancer::Storage.get_player["id"]
+        choices += options.map{|o| {name: "#{o["humanized_title"]} -> weight: #{o["total_weight"]}", value: o}}
+      end
 
+      _muh_method = __method__.to_sym
       Thread.main[:menu_options][__method__.to_sym] = choices
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :back, proc: Proc.new{
@@ -603,22 +639,24 @@ module Aromancer
           end
         }},
         {value: :player_word, proc: Proc.new{
-          wytyd = I18n.t("routes.legend.place_on_scroll", word: selected_word["value_display"])
-          Aromancer::Prompt.say(wytyd)
-          Aromancer::Api.create_turn({
-            wytyd: wytyd,
-            word_id: selected_word["id"]
-          })
-          legend_menu
+          Aromancer::Prompt.say(I18n.t("shared.waiting"))
+          Thread.main[:menu_options][_muh_method] = []
+          Thread.main[:menu_runners][_muh_method] = []
+          Aromancer::Api.submit_turn(request_uuid)
+          # websockets will trigger this for other player after turn is submitted
+          Aromancer::Api.get_legends
+          Aromancer::Api.load_arena
+          sleep(1)
         }},
         {value: nil, proc: Proc.new{|o|
-          if o["http_verb"] == "post"
-            Aromancer::Api.create_turn(JSON.parse(o["payload"]))
-          else
-            Aromancer::Api.update_turn(JSON.parse(o["payload"]))
-          end
-
-          legend_menu
+          Aromancer::Prompt.say(I18n.t("shared.waiting"))
+          Thread.main[:menu_options][_muh_method] = []
+          Thread.main[:menu_runners][_muh_method] = []
+          Aromancer::Api.submit_turn(request_uuid, {option_uuid: o[:uuid.to_s]})
+          # websockets will trigger this for other player after turn is submitted
+          Aromancer::Api.get_legends
+          Aromancer::Api.load_arena
+          sleep(1)
         }}
       ]
       Thread.main[:route_params] = [selected_word_id]

data/lib/aromancer/serve.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+=begin
+
+  serve.rb
+
+  aromancer serve functionality.
+
+  by i2097i
+
+=end
+
+module Aromancer
+  class Serve
+    SERVER_NAME = :"#{Aromancer.to_s.downcase}_serve".to_s
+
+    def self.run
+      unless Dir.exist?(serve_dir)
+        system(:"git clone git@github.com:arowmancy/#{SERVER_NAME}.git #{serve_dir}".to_s)
+      end
+      FileUtils.chdir serve_dir do
+        branch = "v#{Aromancer::VERSION}"
+        system(:"git checkout #{branch}".to_s)
+        system(:"git pull origin #{branch}".to_s)
+        system(:"bin/setup".to_s)
+      end
+    end
+
+    private
+
+    def self.serve_dir
+      File.join(Aromancer.home_directory, SERVER_NAME)
+    end
+  end
+end

data/lib/aromancer/server.rb

@@ -22,7 +22,6 @@ module Aromancer
       def initialize(status: -1, body: {})
         @status = status
         @body = body
-        Aromancer::Storage.instance.clear_cache!
       end
 
       def self.build(e)
@@ -141,7 +140,7 @@ module Aromancer
       end
     end
 
-    def self.get_stream
+    def self.get_stream(count = nil)
       legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
       return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
 
@@ -149,7 +148,7 @@ module Aromancer
         Faraday.new(
           url: Aromancer::Storage.get_server_url,
           headers: HEADERS.merge(auth_header),
-        ).get("/legends/#{legend_id}/stream")
+        ).get("/legends/#{legend_id}/stream?count=#{count || nil}")
       rescue StandardError => e
         InternalError.build(e)
       end
@@ -169,7 +168,7 @@ module Aromancer
       end
     end
 
-    def self.create_turn(params)
+    def self.submit_turn(request_uuid, params = {})
       legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
       return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
 
@@ -178,22 +177,18 @@ module Aromancer
           url: Aromancer::Storage.get_server_url,
           headers: HEADERS.merge(auth_header),
           params: params
-        ).post("/legends/#{legend_id}/arena")
+        ).put("/legends/#{legend_id}/arena/#{request_uuid}")
       rescue StandardError => e
         InternalError.build(e)
       end
     end
 
-    def self.update_turn(params)
-      legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
-      return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
-
+    def self.load_rules
       begin
         Faraday.new(
           url: Aromancer::Storage.get_server_url,
           headers: HEADERS.merge(auth_header),
-          params: params
-        ).put("/legends/#{legend_id}/arena")
+        ).get("/")
       rescue StandardError => e
         InternalError.build(e)
       end