root/trunk/acceptance/epic4.rb

#!/usr/bin/env ruby
#
#       FaerieMUD - The Hidden Path - Epic 4: Action
#
# == Authors
# 
# * Michael Granger <ged@FaerieMUD.org>
# * Martin Chase <stillflame@FaerieMUD.org>
# * Aidan Rogers <aidan@FaerieMUD.org>
# 
# == Legal
# 
# Copyright (c) 2000-2005 The FaerieMUD Consortium. Some rights reserved.
# 
# This is free software. You may use, modify, and/or redistribute this software
# under the terms of the Creative Commons Attribution-NonCommercial-ShareAlike
# license, version 2.0 or greater.
# 
# See http://creativecommons.org/licenses/by-nc-sa/2.0/ for more information.
#


# Put some local directories in the load path
BEGIN {
        $basedir = File.dirname( File.dirname(__FILE__) )

        %w{lib redist}.each do |dir|
                $LOAD_PATH.unshift( File.join($basedir, dir) )
        end
}

require "#$basedir/utils"
require "fm"
require 'fm/mixins'
require 'fm/linguistics'


### Clocks can 'tick'
class TickVerb < FaerieMUD::Verb
        def invoke( instigator, origin=nil )
                origin ||= instigator
                return FaerieMUD::AuditoryEvent.new(
                        :instigator => instigator,
                        :origin => origin,
                        :verb => self,
                        :noticability => 0.05
                        )
        end
end

### ...and also 'chime'
class ChimeVerb < FaerieMUD::Verb
        def invoke( instigator, origin=nil )
                origin ||= instigator
                return FaerieMUD::AuditoryEvent.new(
                        :instigator => instigator,
                        :origin => origin,
                        :verb => self,
                        :noticability => 0.25
                        )
        end
end

### Clock is a Locus instead of an Instrument for purposes of simplification.
class Clock < FaerieMUD::Locus

        ### Create a new clock object. You can configure the object with the 
        ### following attributes:
        ### [:count]::  Specify how many ticks the clock should generate before 
        ###                     returning on its thread of execution.
        ### [:interval]:: Specify how many floating-point seconds to sleep between
        ###                       ticks. An +interval+ of +0+ causes the clock to tick as
        ###                               fast as it can.
        def initialize( args={} )
                @thread = nil
                @tickCount = 0
                @verbs = {
                        :tick => TickVerb.instance,
                        :chime => ChimeVerb.instance,
                }
                @count = 120
                @interval = 0.5

                super
        end

        attr_accessor :count, :interval

        ### Start a new thread, start ticking in it and return the thread.      
        def start
                @thread = Thread.new do
                        Thread.current.abort_on_exception = true
                        @count.times do
                                self.tick
                                sleep @interval unless @interval == 0.0
                        end
                end
        end

        ### Execute one tick of the clock, sending appropriate events to 
        ### the environment.
        def tick
                @tickCount += 1
                self.log.debug "Tick %d" % [@tickCount]
                events = @verbs[:tick].invoke( self )
                self.disperse_events( events )
                self.chime if (@tickCount % 10).zero?
        end


        ### Send an auditory chime event to the surrounding environment.
        def chime
                self.log.debug "Chime!"
                events = @verbs[:chime].invoke( self )
                self.disperse_events( events )
        end
end


### The quasi-orc can 'say' stuff.
class SayVerb < FaerieMUD::Verb

        # The speaker will always be both instigator and origin, so combine them in
        # the overridden method. Ventriloquism doesn't count. =:P

        def invoke( speaker, language, words )
                return FaerieMUD::SpeechEvent.new(
                        :instigator => speaker,
                        :origin => speaker,
                        :verb => self,
                        :language => language,
                        :words => words,
                        :noticability => 0.65
                        )
        end
end

### A simulacrum quasi-orc object.
class QuasiOrc < FaerieMUD::Locus

        ### Create a new simulated orc. He will assume he's on duty.
        def initialize
                @onDuty = true
                @chimeCount = 0
                @sayVerb = SayVerb.instance

                super
        end

        ### Handle stuff heard from the environment. QuasiOrcs only care about chimes that tell 
        ### them they're on duty or off.
        def handleAuditoryEvent( ev )
                if ev.verb.class.name =~ /chime/i
                        self.log.debug "Heard a chime!"
                        results = self.respondToChime
                        self.log.debug "Result from responding to chime: %p" %
                                [ results ]
                        self.disperse_events( results ) if results
                else
                        self.log.debug "Ignoring %s" % [ ev.class.name ]
                        # Ignore
                end
        end


        ### Respond to hearing a chime -- he is on duty every three hours.
        def respondToChime
                @chimeCount += 1
                self.changeDutyStatus if ( @chimeCount % 3 ).zero?
        end


        ### After hearing a third chime, either go on duty or come off, and announce it.
        def changeDutyStatus
                @onDuty = !@onDuty

                if @onDuty
                        msg = "Back to work!"
                else
                        msg = "Ah, off duty now."
                end
                
                return @sayVerb.invoke( self, :trade, msg )
        end
end


### A bodiless observer object class -- just reports events observed from its 
### environment to $defout.
class Observer < FaerieMUD::Locus

        include FaerieMUD::Linguistics

        ### Handle events that are sensed through auditory perception
        def handleAuditoryEvent( ev )
                $defout.puts "Observer heard: %s" % describe_event( ev )
        end

        ### Handle auditory events that contain speech specially.
        def handleSpeechEvent( ev )
                prelude = "Observer heard: %s" % describe_event( ev )
                $defout.puts %q{%s, "%s"} % [ prelude, ev.words ]
        end

        ### Handle events sensed through visual perception.
        def handleVisualEvent( ev )
                $defout.puts "Observer saw: %s" % describe_event( ev )
        end

        ### Create a sentence to describe an event.
        def describe_event( ev )
                $deferr.puts ev.inspect

                prep_phrase = "in %s" % objectToNounPhrase( ev.origin ) if ev.origin != ev.instigator
                sentence = Sentence.new( ev.instigator, ev.verb, ev.target, prep_phrase )

                return sentence.to_s
        end

end


if $0 == __FILE__
        if $DEBUG
                FaerieMUD::Logger.global.outputters <<
                        FaerieMUD::Logger::Outputter.create( 'file', $stderr, "STDERR" )
                FaerieMUD::Logger.global.level = :debug
        end

        # Set up the scene 
        topArea = FaerieMUD::Area.new
        punchbag = QuasiOrc.new
        clock = Clock.new
        observer = Observer.new

        # Put the clock and punchbag into the void
        topArea << punchbag
        topArea << clock
        topArea << observer

        # Start the clock ticking
        clock.interval = 0.1
        clock.start.join
end