inform-runtime 1.0.4

data/lib/runtime/daemon.rb

@@ -0,0 +1,266 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2023 but freely usable (see license)
+#
+# This file is part of the Inform Runtime.
+#
+# The Inform Runtime is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The Inform Runtime is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with the Inform Runtime.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'set'
+
+# In order to support atmospheric messages and NPC automation
+# based on timers, I'm trying to come up with an approach for
+# incorporating the Inform 6 version of daemons into a multi-
+# player environment.
+#
+# Perhaps some form of scanner will detect which objects implement
+# the daemon method, and then schedule its invocation once every
+# so often.
+#
+# For scheduled events:
+#
+#     def after_initialize
+#       schedule('every ten minutes') do
+#         do_something
+#       end
+#     end
+#
+# For daemon events:
+#
+#     def daemon
+#       do_something
+#     end
+#
+# The realtime application turns the Inform each_turn method
+# into a synonym for daemon.
+#
+# Timers must also be supported.
+#
+# Object  -> "blue box"
+#   with  name 'blue' 'box',
+#         after [;
+#             SwitchOn: StartDaemon(self);
+#             SwitchOff: StopDaemon(self);
+#             ],
+#         daemon [;
+#             if (IndirectlyContains(location,self))
+#                 "^An ominous ticking noise is coming from the box.";
+#             ],
+#   has   switchable ~on;
+#
+# Object  -> "red box"
+#   with  name 'red' 'box',
+#         after [;
+#             SwitchOn: StartTimer(self,3);
+#             SwitchOff: StopTimer(self);
+#             ],
+#         time_out [;
+#             if (IndirectlyContains(location,self))
+#                 print "^The box explodes into a zillion fragments.^";
+#             remove self;
+#             ],
+#         time_left 0,
+#   has   switchable ~on;
+#
+
+# The Inform module
+module Inform
+  def run_daemons
+    return if defined?(TURN_BASED)
+    Inform::Daemons.start
+  end
+
+  # The Inform::Daemons module
+  module Daemons
+    def spawn
+      @spawn ||= defined?(Java) ? java.util.concurrent.ConcurrentSkipListSet.new : Set.new
+    end
+
+    def heart
+      @heart ||= init_heart
+    end
+
+    def init_heart
+      # TODO: Figure out ruby-concurrency Executors?
+      return unless defined?(Java)
+      java.util.concurrent.Executors.newSingleThreadScheduledExecutor()
+    end
+
+    # The Inform::Daemons::Entheogen class encapsulates a heartbeat which
+    # is a ScheduledFuture created by the Heart executor and instantiated
+    # when Inform::Daemons.start is executed.
+    class Entheogen < Inform::System::Object
+      attr_accessor :heartbeat
+    end
+
+    def ghost
+      @ghost ||= Entheogen.new
+    end
+
+    def schedules
+      @schedules ||= defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : {}
+    end
+
+    def on?
+      return false if Inform::Daemons.ghost.heartbeat.nil?
+      Inform::Daemons.ghost.heartbeat.isCancelled() == false
+    end
+
+    def rescan
+      Inform::Daemons.spawn.clear
+      Inform::Daemons.scan_objects
+    end
+
+    DaemonScanElapsedMessage = "Scanned %<daemons>s daemons in %<elapsed>0.2f milliseconds".freeze
+
+    def self.scan_objects
+      start = Time.now
+      Inform::Object.all.each do |obj|
+        Spawn.add obj if obj.respond_to?(:daemon) || obj.respond_to?(:each_turn)
+      end
+    rescue StandardError => e
+      log.error "Error executing daemon method: #{e.message}", e
+    ensure
+      log.debug format(DaemonScanElapsedMessage, daemons: Spawn.length, elapsed: Time.now - start)
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    def self.start
+      initial_delay = Inform::Game.config[:daemon_initial_delay]
+      period = Inform::Game.config[:daemons_period]
+      unit = defined?(Java) ? java.util.concurrent.TimeUnit::MILLISECONDS : 'milliseconds'
+      Thread.new do
+        Inform::Daemons.rescan
+        log.debug "Starting daemons..."
+        daemons = Inform::Daemons.method(:daemons).to_proc
+        Inform::Daemons.ghost.heartbeat = Inform::Daemons.heart.scheduleAtFixedRate(
+          daemons, initial_delay, period, unit)
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+
+    def self.stop
+      Inform::Daemons.ghost.heartbeat.cancel(false)
+      Inform::Daemons.spawn.clear
+    end
+
+    DaemonExecutionElapsedMessage = "\e[1m\e[33mExecuted daemons in %<elapsed>0.2f milliseconds\e[39m\e[22m".freeze
+
+    def self.daemons
+      start = Time.ms
+      Inform::Daemons.spawn.each do |daemon|
+        # In realtime games, each_turn is a synonym for daemon
+        next unless daemon.respond_to?(:daemon) || daemon.respond_to?(:each_turn)
+        Inform::Daemons.execute daemon
+      end
+    ensure
+      finish = Time.ms
+      elapsed = finish - start
+      log.debug format(DaemonExecutionElapsedMessage, elapsed: elapsed) if finish % 300_000 == 0
+    end
+
+    RecordNotFoundPattern = %r{Record not found}.freeze
+
+    def self.refresh_or_remove(obj)
+      return if obj.nil?
+      obj.refresh
+    rescue StandardError => e
+      Spawn.remove obj if RecordNotFoundPattern.match?(e.message)
+    end
+
+    def self.ensure_inform_library(obj)
+      return unless obj.inflib.nil?
+      # TODO: Use a pool of InformLibraries until
+      # comprehensive event contexts can be implemented
+      log.warn "Using singleton Ghost InformLibrary for #{obj} daemon"
+      obj.inflib = Inform::Runtime.libraries[Inform::Daemons.ghost]
+    end
+
+    # TODO: Potentially go ahead and print any string results
+    # from the daemon invocation.  For example:
+    #
+    #     obj.println obj.daemon
+    def self.execute_daemon(obj)
+      refresh_or_remove(obj)
+      ensure_inform_library(obj)
+      obj.daemon
+    end
+
+    def self.execute_each_turn(obj)
+      refresh_or_remove(obj)
+      ensure_inform_library(obj)
+      obj.each_turn
+    end
+
+    def self.execute(obj)
+      return if obj.nil?
+      if obj.respond_to? :daemon
+        execute_daemon(obj)
+      elsif obj.respond_to? :each_turn
+        execute_each_turn(obj)
+      end
+    rescue StandardError => e
+      log.error "Error executing daemon for #{obj}", e
+    end
+
+    def StartDaemon(obj)
+      Inform::Daemons.spawn.add obj if obj.respond_to?(:daemon) || obj.respond_to?(:each_turn)
+    end
+
+    def StopDaemon(obj)
+      return if obj.nil?
+      log.warn "Stopping daemon: #{obj}"
+      obj.undef_method(:daemon) # TODO: Maybe don't do this
+      Inform::Daemons.spawn.remove obj
+    end
+
+    def StartTimer(obj, interval)
+      # TODO: Implement
+    end
+
+    def StopTimer(obj)
+      # TODO: Implement
+    end
+
+    def daemonize(event)
+      Inform::Daemons.schedules[self] = event
+    end
+
+    def daemonic?
+      Inform::Daemons.schedules.include? self
+    end
+
+    def before_destroy
+      log.debug "#{self}: before_destroy stopping daemon"
+      StopDaemon(self) if daemonic?
+      super
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    def occasionally(time = nil, &block)
+      time = Inform::Game.config[:daemons_frequency_default] if time.nil?
+      return if active? || daemonic?
+      frequency = ((self.&:frequency) || time).to_i
+      occasion = rand(frequency) + 1
+      log.trace "Scheduling occasional daemonic event for #{self} in #{occasion} seconds"
+      (Inform::Daemons.schedules[self] = delay(occasion, &block)).finally do
+        Inform::Daemons.schedules.delete self
+      end
+    end
+  end
+  # rubocop: enable Metrics/AbcSize
+  # module Daemons
+end
+# module Inform