gamefic 0.0.1

data/lib/gamefic/entity_ext/item.rb

@@ -0,0 +1,11 @@
+require "gamefic/entity_ext/itemized"
+require "gamefic/entity_ext/portable"
+
+module Gamefic
+
+	class Item < Entity
+		include Itemized
+		include Portable
+	end
+
+end

data/lib/gamefic/entity_ext/itemized.rb

@@ -0,0 +1,7 @@
+module Gamefic
+
+	module Itemized
+
+	end
+
+end

data/lib/gamefic/entity_ext/portable.rb

@@ -0,0 +1,33 @@
+module Gamefic
+
+	module Portable
+
+	end
+
+	#Action.new("take", Context::ENVIRONMENT) { |actor, object|
+	#	if object.parent == actor
+	#		actor.tell "You're already carrying #{object.longname}."
+	#	else
+	#		if object.kind_of? Portable
+	#			object.parent = actor
+	#			actor.tell "You take #{object.longname}."
+	#		else
+	#			actor.tell "You can't carry #{object.longname}."
+	#		end
+	#	end
+	#}
+	#Parser.translate("get [object]", "take [object]")
+
+	#Action.new("drop", Context::INVENTORY) { |actor, object|
+	#	if object.parent != actor
+	#		actor.tell "You're not carrying it."
+	#	else
+	#		object.parent = actor.parent
+	#		actor.tell "You drop #{object.longname}."
+	#	end
+	#}
+
+	#Parser.translate "drop [object] floor", "drop [object]"
+	#Parser.translate "drop [object] ground", "drop [object]"
+
+end

data/lib/gamefic/entity_ext/portal.rb

@@ -0,0 +1,47 @@
+module Gamefic
+
+	class Portal < Entity
+		attr_accessor :destination
+		#def initialize
+		#	super
+		#	@destination = nil
+		#end
+    def find_reverse
+      rev = Portal.reverse(self.name)
+      if rev != nil
+        destination.children.that_are(Portal).each { |c|
+          if c.name == rev
+            return c
+          end
+        }
+      end
+    end
+		def self.reverse(direction)
+			case direction.downcase
+				when "north"
+					"south"
+				when "south"
+					"north"
+				when "west"
+					"east"
+				when "east"
+					"west"
+				when "northwest"
+					"southeast"
+				when "southeast"
+					"northwest"
+				when "northeast"
+					"southwest"
+				when "southwest"
+					"northeast"
+				when "up"
+					"down"
+				when "down"
+					"up"
+				else
+					nil
+			end
+		end
+	end
+
+end

data/lib/gamefic/entity_ext/room.rb

@@ -0,0 +1,31 @@
+require "gamefic/entity_ext/portal"
+
+module Gamefic
+
+	class Room < Entity
+		def post_initialize
+		
+		end
+		def connect(destination, direction, type = Portal, two_way = true)
+			portal = type.new self.plot, :name => direction, :parent => self, :destination => destination
+			if two_way == true
+				reverse = Portal.reverse(direction)
+				if reverse == nil
+					raise "\"#{direction.cap_first}\" does not have an opposite direction"
+				end
+				portal2 = type.new(self.plot, {
+					:name => reverse,
+					:parent => destination,
+					:destination => self
+				})
+			end
+			portal
+		end
+		def tell(message, refresh = false)
+			children.each { |c|
+				c.tell message, refresh
+			}
+		end
+	end
+
+end

data/lib/gamefic/entity_ext/scenery.rb

@@ -0,0 +1,7 @@
+module Gamefic
+
+	class Scenery < Entity
+
+	end
+
+end

data/lib/gamefic/entity_ext/zone.rb

@@ -0,0 +1,8 @@
+module Gamefic
+
+	# An optional class for grouping entities.
+	class Zone < Entity
+	
+	end
+
+end

data/lib/gamefic/keywords.rb

@@ -0,0 +1,39 @@
+# Arrays of keywords that can be compared for matches.
+
+module Gamefic
+
+	class Keywords < Array
+		def initialize(statement = '')
+			if statement.kind_of?(Keywords)
+				self.concat statement
+			else
+				self.concat statement.to_s.gsub(/[^a-z0-9]/i, ' ').strip.downcase.split(' ')
+			end
+			self.delete_if { |w|
+				w.length < 2 or w == 'an' or w == 'the'
+			}
+			self.uniq!
+		end
+		def found_in(other)
+			matches = 0.0
+			self.each { |my_word|
+				if (other.include?(my_word))
+					matches = matches + 1.0
+				else
+					other.each { |other_word|
+						if my_word.length < other_word.length
+							if other_word[0, my_word.length] == my_word
+								matches = matches + (my_word.length.to_f / other_word.length.to_f)
+							end
+						end
+					}
+				end
+			}
+			return matches
+		end
+		def to_s
+			self.join(' ')
+		end
+	end
+
+end

data/lib/gamefic/node.rb

@@ -0,0 +1,62 @@
+module Gamefic
+
+	module Node
+		def children
+			if @children == nil
+				@children = Array.new
+			end
+			@children.clone
+		end
+		def flatten
+			array = Array.new
+			children.each { |child|
+				array = array + recurse_flatten(child)
+			}
+			return array
+		end
+		protected
+		def add_child(node)
+			children
+			@children.push(node)
+		end
+		def rem_child(node)
+			children
+			@children.delete(node)
+		end
+		def concat_children(children)
+			children
+			@children.concat(children)
+		end
+		private
+		def recurse_flatten(node)
+			array = Array.new
+			array.push(node)
+			node.children.each { |child|
+				array = array + recurse_flatten(child)
+			}
+			return array
+		end
+	end
+	
+	module Branch
+		include Node
+		def parent
+			@parent
+		end
+		def parent=(node)
+			if node == self
+				raise "Entity cannot be its own parent"
+			end
+			if @parent != node
+				if @parent != nil
+					@parent.send(:rem_child, self)
+				end
+				@parent = node
+				if @parent != nil
+					@parent.send(:add_child, self)
+				end
+			end
+		end
+	end
+
+end

data/lib/gamefic/plot.rb

@@ -0,0 +1,188 @@
+module Gamefic
+
+	class Plot
+		attr_reader :scenes, :commands, :conclusions, :declared_scripts
+		attr_accessor :story
+		def commandwords
+			words = Array.new
+			@syntaxes.each { |s|
+				words.push(s.template.split_words[0])
+			}
+			words.uniq
+		end
+		def initialize
+			@scenes = Hash.new
+			@commands = Hash.new
+			@syntaxes = Array.new
+			@conclusions = Hash.new
+			@update_procs = Array.new
+			@declared_scripts = Array.new
+			@entities = Array.new
+			post_initialize
+		end
+		def post_initialize
+			Action.defaults.each {|a|
+				add_action a
+			}
+			Syntax.defaults.each {|s|
+				add_syntax s
+			}
+		end
+		#def require_defaults
+			#Dir[File.dirname(__FILE__) + '/entity_ext/*.rb'].each do |file|
+			#	require file
+			#end
+			#Dir[File.dirname(__FILE__) + '/action_ext/*.rb'].each do |file|
+			#	require_script file
+			#end
+		#end
+		def action(command, *queries, &proc)
+			act = Action.new(self, command, *queries, &proc)
+		end
+		def respond(command, *queries, &proc)
+			self.action(command, *queries, &proc)
+		end
+		def entity(cls, args)
+			ent = cls.new(self, args)
+			if ent.kind_of?(Entity) == false
+				raise "Invalid entity class"
+			end
+			#@entities.push ent
+			ent
+		end
+		def make(cls, args = {})
+			self.entity(cls, args)
+		end
+		def syntax(*args)
+			syn = Syntax.new(self, *args)
+			@syntaxes.push syn
+			syn
+		end
+		def xlate(*args)
+			syntax(*args)
+		end
+		#def add_entity(entity)
+		#	if @entities.include?(entity) == false
+		#		@entities.push entity
+		#	end
+		#end
+		def rem_entity(entity)
+			@entities.delete(entity)
+		end
+		def entities
+			@entities.clone
+		end
+		def syntaxes
+			@syntaxes.clone
+		end
+		def on_update(&block)
+			@update_procs.push block
+		end
+		def introduction (&proc)
+			@introduction = proc
+		end
+		def conclusion(key, &proc)
+			@conclusions[key] = proc
+		end
+		def scene(key, &proc)
+			@scenes[key] = proc
+		end
+		def introduce(player)
+			if @introduction != nil
+				@introduction.call(player)
+			end
+		end
+		def conclude(player, key = nil)
+			if key != nil and @conclusions[key]
+				@conclusions[key].call(player)
+			end
+		end
+		def cue scene
+			@scenes[scene].call
+		end
+		def passthru
+			Director::Delegate.passthru
+		end
+		def update
+			@update_procs.each { |p|
+				p.call
+			}
+			#@entities.flatten.each { |e|
+      @entities.each { |e|
+				#recursive_update e
+				e.update
+			}
+		end
+		def tell entities, message, refresh = false
+			entities.each { |entity|
+				entity.tell message, refresh
+			}
+		end
+		def load_script filename
+			plot = self
+			eval File.read(filename), nil, filename, 1
+		end
+		def require_script filename
+			if @declared_scripts.include?(filename) == false
+				@declared_scripts.push(filename)
+				load_script filename
+			end
+		end
+		private
+		def recursive_update(entity)
+			entity.update
+			entity.children.each { |e|
+				recursive_update e
+			}
+		end	
+		def add_syntax syntax
+			if @commands[syntax.command] == nil
+				raise "Action \"#{syntax.command}\" does not exist"
+			end
+			@syntaxes.unshift syntax
+			@syntaxes.sort! { |a, b|
+				al = a.template.split_words.length
+				bl = b.template.split_words.length
+				if al == bl
+					# For syntaxes of the same length, creation order takes precedence
+					0
+				else
+					bl <=> al
+				end
+			}			
+		end
+		def add_action(action)
+			if (@commands[action.command] == nil)
+				@commands[action.command] = Array.new
+			end
+			@commands[action.command].unshift action
+			@commands[action.command].sort! { |a, b|
+				if a.specificity == b.specificity
+					# For actions of the same length, creation order takes precedence
+					0
+				else
+					b.specificity <=> a.specificity
+				end
+			}
+			user_friendly = action.command.to_s.sub(/_/, ' ')
+			args = Array.new
+			used_names = Array.new
+			action.queries.each { |c|
+				num = 1
+				new_name = "var"
+				while used_names.include? new_name
+					num = num + 1
+					new_name = "var#{num}"
+				end
+				used_names.push new_name
+				user_friendly += " :#{new_name}"
+				args.push new_name.to_sym
+			}
+			Syntax.new self, *[user_friendly, action.command] + args
+		end
+		def add_entity(entity)
+			@entities.push entity
+		end
+	end
+
+end

data/lib/gamefic/query.rb

@@ -0,0 +1,187 @@
+require "gamefic/keywords"
+
+module Gamefic
+
+	class Query
+    FAMILY   = :family
+    CHILDREN = :children
+    SIBLINGS = :siblings
+    PARENT   = :parent
+    SELF     = :self
+    PLOT     = :plot
+    STRING   = :string
+		def initialize(context, *arguments)
+			if context != :family and context != :children and context != :siblings and context != :parent and context != :self and context != :plot and context != :string
+				raise "Invalid Query context '#{context}'"
+			end
+			#if context == :string and arguments.length > 0
+			#	raise "Query with :string context cannot take additional arguments."
+			#end
+			@context = context
+			@arguments = arguments
+		end
+		def execute(subject, description)
+			case context
+				when :self
+					array = [subject]
+				when :parent
+					array = [subject.parent]
+				when :plot
+					array = subject.plot.entities
+				when :children
+					array = subject.children
+				when :siblings
+					array = subject.parent.children
+				when :family
+					array = subject.children + subject.parent.children
+				when :string
+          if @arguments.length == 0
+            return Matches.new([description], description, '')
+          end
+          keywords = Keywords.new(description)
+          args = Keywords.new(@arguments)
+          found = Array.new
+          remainder = Array.new
+          keywords.each { |key|
+            if args.include?(key)
+              found.push key
+            else
+              remainder.push key
+            end
+          }
+          if found.length > 0
+            return Matches.new([description], found.join(' '), remainder.join(' '))
+          else
+            return Matches.new([], '', description)
+          end
+				else
+					raise "Unrecognized: #{context}"
+			end
+			@arguments.each { |arg|
+				if arg.kind_of?(Class) or arg.kind_of?(Module)
+					array.delete_if { |entity| entity.kind_of?(arg) == false }
+				else
+					if array.include?(arg)
+						array = Array.new
+						array.push(arg)
+					else
+						array.clear
+					end
+				end
+			}
+			return Query.match(description, array)
+		end
+		def context
+			@context
+		end
+		def Query.match(description, array)
+			array.each {|e|
+				if e.uid == description
+					return Matches.new([e], description, '')
+				end
+			}
+			keywords = description.split_words
+			results = array
+			used = Array.new
+			if results.length > 0
+				previous_match = false
+				while keywords.length > 0
+					used.push keywords.shift
+					new_results = Array.new
+					mostMatches = 0.0
+					results.each { |r|
+						words = Keywords.new(used.join(' '))
+						if words.length > 0
+							matches = words.found_in r.keywords
+							if matches >= mostMatches and matches > 0
+								if matches - mostMatches > 0.5
+									new_results = Array.new
+								end
+								new_results.push r
+								mostMatches = matches
+							end
+						end
+					}
+					if new_results.length == 0
+						if previous_match == true
+							keywords.unshift used.pop
+							if used.length == 0
+								results = new_results
+							end
+							break
+						end
+					else
+						previous_match = true
+						results = new_results
+						if results.length == 1
+							break
+						end
+					end
+				end
+				if previous_match == false
+					# Scrolled through every word and not a single thing matched
+					results = Array.new
+				end
+			end
+			return Matches.new(results, used.join(' '), keywords.join(' '))
+		end
+		def Query.match_one(description, array)
+			result = self.match(description, array)
+			if result.objects.length == 1
+				return result.objects[0]
+			end
+			return nil
+		end
+		def specificity
+			if @specificity == nil
+				@specificity = 0
+				case @context
+					when :children
+						@specificity += 50
+					when :siblings
+						@specificity += 40
+					when :family
+						@specificity += 30
+					when :parent
+						@specificity += 20
+					when :self
+						@specificity += 10
+					when :string
+						@specificity = 1
+						#return @specificity
+				end
+				magnitude = 1
+				@arguments.each { |item|
+					if item.kind_of?(Entity)
+						@specificity += (magnitude * 10)
+						item = item.class
+					end
+					if item.kind_of?(Class)
+						s = item
+						while s != nil
+							@specificity += magnitude
+							s = s.superclass
+						end
+					else
+						@specificity += magnitude
+					end
+					magnitude = magnitude * 10
+				}
+			end
+			@specificity
+		end
+		class Matches
+			attr_reader :objects, :matching_text, :remainder
+			def initialize(objects, matching_text, remainder)
+				@objects = objects
+				@matching_text = matching_text
+				@remainder = remainder
+			end
+		end
+	end
+
+	class Subquery < Query
+	
+	end
+	
+end