Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- require 'rubygems'
- gem 'facets'
- require 'facets'
- require 'facets/random'
- require 'mathn'
- # Common-common-common............................17
- # Pattern meowtching.............................175
- # Long-named class definitions...................230
- # Yiff algebra...................................296
- # Library........................................425
- # Frozen Synapse interface......................1243
- # Kama Sutra....................................1300
- # Brool Stories, Inc............................1468
- # ---- Common-common-common ----
- Map = Hash
- class Map
- def key_and_value
- self.to_a.only
- end
- end
- # :call-seq:
- # oalias new_method_id => old_method_id
- #
- # creates alias which always references overriden method rather than
- # original one (Ruby's +alias+ keyword creates method which always
- # references not overriden method).
- #
- # The name is abbreviation for "overridable alias".
- #
- def oalias(arg)
- begin
- new_method_id, old_method_id = arg.key_and_value
- define_method new_method_id, self.instance_method(old_method_id)
- rescue NoMethodError
- eval <<-RUBY
- def #{new_method_id}(*args, &block)
- #{old_method_id}(*args, &block)
- end
- RUBY
- end
- end
- class AssertionFailedError < Exception
- end
- def assert(condition, msg = "Assertion failed")
- raise AssertionFailedError.new(msg) unless condition
- end
- # :private-to-module:
- $last_mentioned_items = []
- class Array
- oalias :add => :<<
- oalias :present? => :not_empty?
- # "item_1, item_2, ..., item_(n-1) and item_n"
- def to_nat_s
- $last_mentioned_items = self
- self.conjoin(", ", " and ")
- end
- end
- class Object
- def eigen_class
- class << self; self; end
- end
- end
- class Numeric
- def seconds
- self
- end
- alias second seconds
- alias sec seconds
- alias s seconds
- def minutes
- 60 * self
- end
- alias minute minutes
- alias min minutes
- alias m minutes
- def hours
- 60 * minutes
- end
- alias hour hours
- alias h hours
- def percent
- self / 100
- end
- def to_time_s
- secs = self.floor
- h = (secs / 3600).floor
- m = ((secs % 3600) / 60).floor
- s = self - h.hours - m.minutes
- s = s.round_to(0.0001) if not s.is_a?(Integer)
- r = "#{s}s"
- r = "#{m}m " + r if m > 0
- r = "#{h}h " + r if h > 0
- return r
- end
- end
- # Unique integer.
- def unique
- return $next_unique.tap { $next_unique += 1 }
- end
- # :private-to-module:
- $next_unique = 0
- Inf = 1.0/0.0
- # returns "s" for +items+ of size 1 and "ve" for +items+ of another size.
- # By default +items+ are items which Array#to_nat_s() has been last called for.
- def s_or_ve(items = $last_mentioned_items)
- if items.one? then "s"
- else "ve"; end
- end
- # returns "is" for +items+ of size 1 and "are" for +items+ of another size.
- # By default +items+ are items which Array#to_nat_s() has been last called for.
- def is_or_are(items = $last_mentioned_items)
- if items.one? then "is"
- else "are"; end
- end
- def yes; true; end
- def no; false; end
- class Module
- def to_proc
- lambda { |arg| self.new(arg) }
- end
- end
- # ---- Pattern meowtching ----
- class Array
- def ===(other)
- return false unless other.is_a?(Array) or other.respond_to?(:to_a)
- other = other.to_a
- i_self = 0
- i_other = 0
- loop do
- if self[i_self].is_a? Many1
- assert(i_self == self.size - 1)
- return false unless self[i_self].what === other[i_other]
- i_other += 1
- return true if i_other >= other.size
- else
- return false unless self[i_self] === other[i_other]
- i_self += 1
- i_other += 1
- return true if i_self >= self.size and i_other >= other.size
- end
- end
- end
- end
- # :private-to-module:
- class Many1 < Struct.new(:what)
- end
- # "One or many +obj+-s".
- def many1(obj)
- Many1.new(obj)
- end
- # An object which is case equal ("===") to anything.
- def any; Placeholder.new; end
- alias _ any
- # :private-to-module:
- class Placeholder
- def ===(other)
- true
- end
- def to_s; "_"; end
- end
- # ---- Long-named class definitions ----
- # Example of usage:
- #
- # include LongNamedClassDefinitions
- #
- # class Something
- # def m(); puts "Do something"; end
- # end
- #
- # Something "Other",
- # m { puts "Do other thing" }
- #
- # Something("Other").m() #=> Do other thing
- # puts Something("Other").class #=> Other
- #
- module LongNamedClassDefinitions
- begin
- @@long_named_classes = Map.new # [parent class name, class name] -> Class
- end
- CLASS_NAME = /[A-Z].*/
- def method_missing(method_id, *args, &block)
- case [method_id.to_s, args, block]
- when [_, [], Proc]
- MethodDef.new(method_id, block)
- when [CLASS_NAME, [String, many1(MethodDef)], nil]
- parent_class_name = method_id.to_s
- class_name = args[0]
- method_defs = args[1..-1]
- clazz = eval <<-RUBY
- class ::#{internal_class_name = "LongNamedClass#{unique}"} < ::#{parent_class_name}
- def self.to_s
- #{class_name.inspect}
- end
- end
- #{internal_class_name}
- RUBY
- clazz.instance_eval {
- method_defs.each { |method_def|
- define_method method_def.method_id, &method_def.code
- }
- }
- @@long_named_classes[[parent_class_name, class_name]] = clazz
- when [CLASS_NAME, [String], nil]
- parent_class_name = method_id.to_s
- class_name = *args
- clazz = @@long_named_classes[[parent_class_name, class_name]]
- raise %Q{Class #{parent_class_name} "#{class_name}" is not declared} if clazz == nil
- clazz.new
- else
- super(method_id, *args, &block)
- end
- end
- private
- class MethodDef < Struct.new(:method_id, :code)
- end
- end
- # ---- Yiff algebra ----
- class Yiff
- # :immutable:
- class Detail
- # returns DetailsSet.
- def * other
- DetailsSet.new([self]) * other
- end
- # :overridable:
- #
- # The same as #exclude_sets but should return a single entry.
- #
- def exclude_set
- unique
- end
- # :overridable
- #
- # There can not be two Detail-s with intersecting #exclude_sets
- # in single DetailsSet.
- #
- def exclude_sets
- [exclude_set]
- end
- # :overridable:
- #
- # Detail-s with less #priority are located in DetailsSet first.
- #
- def priority
- 0
- end
- def == other
- self.class == other.class
- end
- oalias :eql? => :==
- oalias :=== => :==
- def hash
- self.class.hash
- end
- protected
- # forwards all unknown methods to #yiff.
- def method_missing(method_id, *args, &block)
- yiff.__send__(method_id, *args, &block)
- end
- end
- # :immutable:
- # :not-inheritable:
- class DetailsSet
- is Enumerable
- def initialize(details)
- assert details.is_a?(Enumerable) and details.all? { |d| d.is_a?(Detail) }
- #
- @details = details
- end
- def each(&block)
- details.each(&block)
- end
- def * other
- case other
- when Detail
- Set.new(
- (self.details.reject { |detail| (detail.exclude_sets & other.exclude_sets).not_empty? } + [other]).
- per.sort_by.priority
- )
- when Set
- other.details.reduce(self, :*)
- else
- raise ArgumentError, "#{other.inspect} must be #{Set} or #{Detail}"
- end
- end
- def / other
- # / Fix for KWrite syntax coloring engine.
- Set.new(self.details -
- if other.is_a? Set then other.details
- else [other]; end
- )
- end
- def == other
- self.class == other.class and
- self.details == other.details
- end
- oalias :eql? => :==
- def === other
- self.class == other.class and
- self.details === other.details
- end
- def hash
- details.hash
- end
- private
- Set = DetailsSet
- attr_reader :details
- # Workaround for Ruby bug.
- protected :details
- end
- NO_DETAILS = DetailsSet.new([])
- end
- # ---- Library ----
- def log(msg)
- puts msg
- end
- class Furry
- def initialize(name, description = "")
- @name = name
- @description = description
- @reminiscences = []
- end
- # :immutable:
- attr_reader :name
- # :immutable:
- attr_reader :description
- # :immutable:
- attr_reader :reminiscences
- def remember(event)
- @reminiscences.add event
- end
- def says(msg)
- log %Q{#{self} says: "#{msg}"}
- end
- def to_s
- name
- end
- end
- module Male
- end
- M = Boy = Male
- module Female
- end
- F = Girl = Female
- class Module
- # returns Array of this Module and +other+.
- #
- # This allows to write things like "M/F", "F/M/F" etc.
- #
- def / other
- # / Fix for KWrite syntax coloring engine.
- return [self, other]
- end
- end
- class Array
- # See Module#/().
- def / other
- # / Fix for KWrite syntax coloring engine.
- return self + [other]
- end
- end
- # All subclasses of Furry class.
- %Q{
- Lion (Lioness)
- Tiger (Tigress)
- Fox (Vixen)
- Wolf (Wolfess)
- Deer
- Horse
- Gator
- }.strip.newlines.each do |entry|
- species, female_species = *(entry.chomp(")").split("(", 2).every.strip)
- male_species = "Male#{species}"
- female_species ||= "Female#{species}"
- eval <<-RUBY
- class #{species} < Furry
- def self.to_s
- "#{species.methodize.gsub("_", " ")}"
- end
- end
- def #{species.methodize}(*args, &block)
- #{species}.new(*args, &block)
- end
- class #{male_species} < #{species}
- is Male
- def self.to_s
- "#{male_species.methodize.gsub("_", " ")}"
- end
- end
- def #{male_species.methodize}(*args, &block)
- #{male_species}.new(*args, &block)
- end
- class #{female_species} < #{species}
- is Female
- def self.to_s
- "#{female_species.methodize.gsub("_", " ")}"
- end
- end
- def #{female_species.methodize}(*args, &block)
- #{female_species}.new(*args, &block)
- end
- RUBY
- end
- class Yiff
- def initialize(furries)
- @partners = Partners.new(furries.map &Partner)
- @details = NO_DETAILS
- #
- furries.every.remember(yiff)
- end
- # See Yiff::Partners.
- attr_reader :partners
- # :call-seq:
- # partner[furry]
- # partner(furry)
- #
- # returns Partner from this Yiff which corresponds to +furry+.
- #
- def partner(*args)
- case args
- when []
- partners
- when [Furry]
- furry = *args
- partners[furry]
- else
- raise ArgumentError, args.inspect
- end
- end
- oalias :p => :partner
- oalias :[] => :partner
- def boys
- partners.select { |partner| partner.is_a? Boy }
- end
- def boy
- boys.only
- end
- def boy1
- boys[0]
- end
- def boy2
- boys[1]
- end
- def girls
- partners.select { |partner| partner.is_a? Girl }
- end
- def girl
- girls.only
- end
- attr_reader :details
- # NOTE: Detail#apply!() of the +value+ is called <em>after</em>
- # #details become equal to +value+.
- def details=(value)
- value = value * NO_DETAILS unless value.is_a? DetailsSet
- assert value.is_a? DetailsSet
- #
- old_details = @details
- begin
- @details = value.with_regard_to(yiff)
- @details.apply!
- rescue
- @details = old_details
- raise
- end
- end
- # perform this Yiff at most for +duration+ (the method may return earlier,
- # for example, due to some partner having finished).
- #
- # It returns this Yiff.
- #
- def perform_at_most_for(duration)
- # Some workaround...
- details = self.details
- partners = self.partners
- #
- if partners.any? { |partner| partner.finished? } and not details.any? { |detail| detail.continue_if_someone_finished? }
- log %Q{(#{partners.to_nat_s} can not continue yiffing because #{partners.select { |p| p.finished?}.to_nat_s} ha#{s_or_ve} finished)}
- return self
- end
- # Exclude finished partners.
- partners = partners.reject { |p| p.finished? }
- # Limit duration until nearest cum.
- duration = duration.at_most partners.every.time_until_cum_left.min
- # Yiff!
- if duration != 0 then log "#{(details.every.description + ["they are moving"]).to_nat_s} for #{duration.to_time_s}."
- else log "#{details.description}."; end
- details.every.when_yiffing()
- partners.each { |partner| partner.time_until_cum_left -= duration }
- # Cum (if any)!
- partners.each do |partner|
- next unless partner.finished?
- # Cum!
- partner.orgasm!
- details.when_cumming(partner)
- if partner.is_a? Boy then partner.satisfied!; end
- end
- #
- return self
- end
- # The same as #perform_for() but with +duration+ set to 0.
- # It may be needed, for example, to apply some one-time Detail-s.
- def perform
- yiff.perform_at_most_for(0)
- end
- # "Let's do it one more time!"
- #
- # It calls Partner#needs_more!() on #partners which are
- # Partner#finished?.
- #
- # It returns this Yiff.
- #
- def one_more_time!
- partners.per.select.finished?.every.needs_more!
- return self
- end
- oalias :continue! => :one_more_time!
- # interrupts this Yiff and returns it.
- def interrupted!
- log "#{partners.per.reject.finished?.to_nat_s} ha#{s_or_ve} stopped yiffing."
- return self
- end
- oalias :at_most_for => :perform_at_most_for
- oalias :do => :perform
- # See source code.
- def reset_details()
- self.details = NO_DETAILS
- return self
- end
- # :call-seq:
- # then { ... }
- # then()
- # then(additional_details)
- #
- # In the first form it executes the block and returns this Yiff.
- # In the second form it just returns this Yiff.
- # In the third form... see source code, I'm too lazy.
- #
- def then(additional_details = nil, &block)
- case [additional_details, block]
- when [nil, Proc]
- block.call
- return self
- when [nil, nil]
- return self
- when [_, nil]
- yiff.details *= additional_details
- return yiff
- end
- end
- oalias :and => :then
- oalias :now => :then
- # Nah, see source code.
- def not(excluded_details)
- yiff.details /= excluded_details
- return self
- end
- # This Yiff.
- def yiff; self; end
- def to_s
- "yiff between #{partners.to_nat_s}"
- end
- # NOTE: It is wrapper for Furry.
- # NOTE: It is instantiable (see Partner#new).
- module Partner
- def self.new(furry)
- # To be a truly wrapper for Furry an instance of the Partner
- # must be of the same class as the furry instance (or of its
- # subclass). Ensure it.
- partner_class = eval <<-RUBY
- class ::#{furry.class.name}
- class YiffPartner < #{furry.class.name}
- include Yiff::Partner
- # Undefine all methods so they can be forwarded to
- # the furry automatically.
- # Don't forget about the Ruby bug that "__send__" does
- # not call "method_missing".
- #{
- furry.class.instance_methods.
- reject do |furry_method_id|
- furry_method_id.in? %W{
- __send__
- __id__
- method_missing
- __class__
- class
- respond_to?
- is_a?
- kind_of?
- initialize
- ==
- }
- end.
- map do |furry_method_id|
- <<-RUBY
- def #{furry_method_id}(*args, &block)
- method_missing(:#{furry_method_id}, *args, &block)
- end
- RUBY
- end.join
- }
- end
- YiffPartner
- end
- RUBY
- #
- partner_class.new(furry)
- end
- def initialize(furry)
- @furry = furry
- @time_until_cum = Inf
- @progress_left = 1 # [1; 0]
- @orgasms_count = 0
- @satisfied = false
- end
- # :immutable:
- attr_reader :orgasms_count
- # Time this Partner needs to cum (as if this Yiff would start
- # from zero, not from current time point; see #time_until_cum_left).
- #
- # See also #time_until_cum_left.
- #
- attr_accessor :time_until_cum
- # Time this Partner needs to cum (from current time point).
- def time_until_cum_left
- if self.finished? then Inf
- else time_until_cum * @progress_left; end
- end
- def time_until_cum_left=(new_time_until_cum_left)
- @progress_left = new_time_until_cum_left / time_until_cum
- end
- def finished?
- @progress_left == 0
- end
- def just_started?
- @progress_left == 1
- end
- def orgasm!
- log %Q{#{self} has got ORGASM!}
- @orgasms_count += 1
- end
- def satisfied?
- @satisfied
- end
- def satisfied!
- log %Q{#{self} is SATISFIED.}
- @satisfied = true
- end
- # sets #satisfied?() and finished?() to false.
- def needs_more!
- log %Q{#{self} needs more.}
- @satisfied = false
- @progress_left = 1
- end
- def ==(other)
- super(other) or @furry == other
- end
- # forwards all unknown methods to Furry passed via constructor.
- def method_missing(method_id, *args, &block)
- @furry.__send__(method_id, *args, &block)
- end
- end
- class Partners
- is Enumerable
- def initialize(partners_array)
- @partners_array = partners_array
- end
- def each(&block)
- @partners_array.each(&block)
- end
- # returns Yiff::Partner from this Partners which corresponds to +furry+.
- def [](furry)
- @partners_array.find { |p| p == furry }
- end
- def to_nat_s
- @partners_array.to_nat_s
- end
- def to_a
- @partners_array
- end
- end
- class Detail
- def initialize(yiff = nil)
- @yiff = yiff
- end
- # Yiff this Detail is considered with regard to.
- attr_reader :yiff
- # returns this Detail considered with regard to +yiff+.
- def with_regard_to(yiff)
- self.class.new(yiff)
- end
- oalias :for => :with_regard_to
- # :accessible-only-for: Yiff
- #
- # applies this Detail to #yiff.
- #
- def apply!
- raise %Q{"#{self}" is unavailable in #{yiff}} unless self.available?
- #
- apply()
- end
- # :overridable:
- #
- # "Is this Detail available in #yiff()?"
- #
- def available?
- true
- end
- # :overridable:
- #
- # "What's going on (in #yiff)?"
- #
- def description
- self.class.to_s
- end
- # :overridable:
- # :accessible-only-for: Yiff
- #
- # is executed when Yiff with this Detail is in progress.
- #
- def when_yiffing()
- end
- # :overridable:
- # :accessible-only-for: Yiff
- #
- # is executed when +partner+ is cumming.
- #
- def when_cumming(partner)
- end
- # :overridable:
- # :accessible-only-for: Yiff
- #
- # Default is false.
- #
- def continue_if_someone_finished?
- false
- end
- def to_s
- self.class.to_s
- end
- # forwards all unknown methods to #yiff.
- def method_missing(method_id, *args, &block)
- yiff.__send__(method_id, *args, &block)
- end
- protected
- # Implementation of #apply!().
- abstract :apply
- end
- class DetailsSet
- # See Detail#with_regard_to().
- def with_regard_to(yiff)
- DetailsSet.new(details.every.with_regard_to(yiff))
- end
- oalias :for => :with_regard_to
- # :accessible-only-for: Yiff
- #
- # See Detail#apply!().
- def apply!
- details.every.apply!
- end
- # See Detail#description.
- def description
- details.every.description.to_nat_s
- end
- # :accessible-only-for: Yiff
- #
- # See Detail#when_cumming().
- def when_cumming(partner)
- details.every.when_cumming(partner)
- end
- def to_s
- details.to_nat_s
- end
- end
- end
- class Array
- # creates Yiff on this Array of Furry-es.
- def yiff
- Yiff.new(self)
- end
- end
- YiffDetail = Yiff::Detail
- class Pose < Yiff::Detail
- def exclude_set
- :poses
- end
- def priority; -1; end
- def available?
- available_for() === yiff.partners and available_if()
- end
- protected
- def apply
- assert times_to_cum.is_a? Map
- times_to_cum.each do |who, time_until_cum|
- who = partner[who] unless who.is_a? Yiff::Partner
- who.time_until_cum = time_until_cum
- end
- end
- # returns Array of genders/species/other of Furry-es participating
- # in Yiff which this Pose is available for.
- abstract :available_for
- # :overridable:
- #
- # additional availability condition. By default it is just +true+.
- #
- def available_if
- true
- end
- # Map: Furry/Yiff::Partner -> time to cum.
- abstract :times_to_cum
- end
- class Yiff
- # Pose this Yiff is being performed in.
- def pose
- details.find { |detail| detail.is_a? Pose } or raise("#{yiff} is not being performed in any #{Pose}")
- end
- # See source code.
- def in(additional_details)
- yiff.then(additional_details)
- end
- end
- class PoseVariation < Yiff::Detail
- # :overridable:
- #
- # NOTE: This property must be higher than Pose#priority.
- #
- def priority; 0; end
- def available?
- poses = self.poses
- poses = [poses] unless poses.is_a? Enumerable
- except_poses = self.except_poses
- except_poses = [except_poses] unless except_poses.is_a? Enumerable
- #
- poses.per.any? === yiff.pose and not except_poses.per.any? === yiff.pose and
- available_for() === yiff.partners and
- available_if()
- end
- protected
- # Pose-s this PoseVariation is available for.
- abstract :poses
- # :overridable:
- #
- # Pose-s this PoseVariation is <em>not</em> available for.
- #
- def except_poses
- []
- end
- # :overridable:
- #
- # Genders/species of Furry-es in #yiff which this PoseVariation is
- # available for.
- #
- def available_for
- any
- end
- # :overridable:
- #
- # Additional availability conditions. By default it is just +true+.
- #
- def available_if
- true
- end
- def apply()
- when_applied()
- end
- # :overridable
- #
- def when_applied
- end
- end
- class Detail < Yiff::Detail
- def priority; -0.5; end
- def available?
- available_for() === yiff.partners and available_if()
- end
- protected
- def apply()
- when_applied()
- end
- # :overridable:
- #
- # See Pose#available_for.
- #
- abstract :available_for
- # :overridable:
- #
- # See Pose#available_if.
- #
- def available_if
- true
- end
- # :overridable:
- #
- def when_applied
- end
- end
- class Range
- # forwards all unknown methods to Range#at_rand() of this Range casted to
- # Range of Float-s (with end included).
- def method_missing(method_id, *args, &block)
- begin
- x = (self.begin.to_f..self.end.to_f).at_rand
- rescue
- super(method_id, *args, &block)
- end
- return super(method_id, *args, &block) unless x.respond_to? method_id
- x.__send__(method_id, *args, &block)
- end
- end
- module StoryTelling
- def tell(msg)
- log "#{msg}"
- end
- class ::String
- alias old_brackets []
- # :call-seq:
- # []
- #
- # Alias for StoryTelling#tell().
- #
- def [](*args)
- if args.empty? then tell self
- else super(*args); end
- end
- end
- #
- # returns +furry+.
- #
- # NOTE: It also declares constant named after +furry+ (if possible) which is
- # equal to the +furry+.
- #
- def lets_meet(furry)
- #
- if furry.description.blank? then tell "Let's meet #{furry} the #{furry.class}."
- else tell "Let's meet #{furry} the #{furry.class}, #{furry.description}."; end
- #
- begin
- $tmp = furry
- eval <<-RUBY
- class ::Object
- #{furry.name.gsub(" ", "_")} = $tmp
- end
- RUBY
- rescue SyntaxError
- # Nah, do nothing.
- ensure
- $tmp = nil
- end
- #
- return furry
- end
- def story(name)
- tell "\n---- #{name} ----\n\n"
- end
- end
- # ---- Frozen Synapse interface ----
- class Yiff
- # returns Plan over this Yiff.
- def planning_phase!
- log "PLANNING PHASE"
- Plan.new(self)
- end
- oalias :plan => :planning_phase!
- # Nah, see source code.
- class Plan
- def initialize(yiff)
- @yiff = yiff
- @actions = []
- end
- def method_missing(method_id, *args, &block)
- @actions.add(proc { @yiff.__send__(method_id, *args, &block) })
- return self
- end
- def prime!
- log "System PRIMED!"
- @actions.per.each.call()
- @actions.clear()
- return @yiff
- end
- end
- end
- class Proc
- # Alias to #call() adapted to Frozen Synapse interface.
- def prime!
- log "System PRIMED"
- self.call()
- end
- end
- # just returns +block+.
- def planning_phase!(&block)
- log "PLANNING PHASE"
- return block
- end
- # ---- Kama Sutra ----
- include LongNamedClassDefinitions
- Pose "Girl on top",
- description { "#{girl} is lying on #{boy}" },
- available_for { M/F },
- times_to_cum {{
- boy => (7..13).minutes,
- girl => (15..17).minutes
- }}
- Pose "Boy on top",
- description { "#{boy} is lying on #{girl}" },
- available_for { M/F },
- times_to_cum {{
- boy => (7..13).minutes,
- girl => (20..23).minutes
- }}
- Pose "Cowgirl",
- description { "#{boy} is lying on back, #{girl} is riding him" },
- available_for { M/F },
- times_to_cum {{
- boy => (5..10).minutes,
- girl => (10..13).minutes
- }}
- Pose "Cunnilingus",
- description { "#{boy} is licking #{girl} at the bottom" },
- available_for { M/F },
- times_to_cum {{
- girl => (5..10).minutes,
- boy => 1.hour
- }}
- PoseVariation "Boy holding her hands",
- description { "#{boy} and #{girl} are holding hands" },
- exclude_sets {[ :boy_hands, :girl_hands ]},
- available_for { M/F },
- poses { any },
- except_poses { Pose "Cunnilingus" },
- when_applied {
- partners.each { |p| p.time_until_cum *= 110.percent }
- }
- PoseVariation "Boy holding breasts",
- description { "#{boy} is squeezing #{girl}'s breasts" },
- exclude_set { :boy_hands },
- available_for { M/F },
- poses { any },
- except_poses { Pose "Cunnilingus" },
- when_applied {
- girl.time_until_cum *= 80.percent
- }
- PoseVariation "Boy holding waist",
- description { "#{boy} is holding #{girl}'s waist" },
- exclude_set { :boy_hands },
- available_for { M/F },
- poses { any },
- when_applied {
- boy.time_until_cum *= 80.percent
- }
- PoseVariation "Boy holding hips",
- description { "#{boy} is holding #{girl}'s hips" },
- exclude_set { :boy_hands },
- available_for { M/F },
- poses { any },
- when_applied {
- boy.time_until_cum *= 80.percent
- girl.time_until_cum *= 80.percent
- }
- PoseVariation "Boy embraces her",
- description { "#{boy} is embracing #{girl}" },
- exclude_set { :boy_hands },
- available_for { M/F },
- poses { any },
- except_poses {[ Pose("Cowgirl"), Pose("Cunnilingus") ]},
- when_applied {
- boy.time_until_cum *= 80.percent
- }
- PoseVariation "They caress each other",
- description { "#{boy} is caressing #{girl}'s waist, her belly, her breasts, #{girl} is caressing him too" },
- exclude_sets {[ :boy_hands, :girl_hands ]},
- available_for { M/F },
- poses { any },
- except_poses {[ Pose("Cowgirl"), Pose("Cunnilingus") ]},
- when_applied {
- boy.time_until_cum *= 70.percent
- girl.time_until_cum *= 70.percent
- }
- PoseVariation "They are kissing",
- description { "#{boy} is kissing #{girl}" },
- exclude_sets {[ :boy_lips, :girl_lips ]},
- available_for { M/F },
- poses { any },
- except_poses {[ Pose("Cowgirl"), Pose("Cunnilingus") ]},
- continue_if_someone_finished? { yes },
- when_applied {
- girl.satisfied! if boy.finished?
- },
- when_cumming { |partner|
- if partner == boy then girl.satisfied!; end
- }
- PoseVariation "Boy kissing breasts",
- description { "#{boy} is kissing #{girl}'s breasts" },
- exclude_set { :boy_lips },
- poses { Pose "Boy on top" },
- when_applied {
- boy.time_until_cum *= 80.percent
- girl.time_until_cum *= 80.percent
- }
- PoseVariation "Girl leans on his chest",
- description { "#{girl} is leaning with hands on #{boy}'s chest" },
- exclude_set { :girl_hands },
- poses { Pose "Cowgirl" }
- PoseVariation "Girl leans at the front and from behind",
- description { "#{girl} is keeping one hand on #{boy}'s stomach and other hand on his leg" },
- exclude_set { :girl_hands },
- poses { Pose "Cowgirl" }
- PoseVariation "Her hands on his hands",
- description { "#{girl} is keeping her hands on #{boy}'s hands"},
- exclude_set { :girl_hands },
- poses { any },
- except_poses { Pose "Cunnilingus" }
- PoseVariation "Girl embraces him",
- description { "#{girl} is embracing #{boy}" },
- exclude_set { :girl_hands },
- poses { any },
- except_poses {[ Pose("Cowgirl"), Pose("Cunnilingus") ]}
- PoseVariation "Girl pushes his shoulders",
- description { "#{girl} is pushing #{boy}'s shoulders" },
- exclude_set { :girl_hands },
- poses { any },
- except_poses { Pose "Cowgirl" }
- PoseVariation "Girl embraces him with legs",
- description { "#{girl} is crossing her legs behing the #{boy}'s back" },
- exclude_set { :girl_legs },
- poses { Pose "Boy on top" },
- when_applied {
- girl.time_until_cum *= 90.percent
- boy.time_until_cum *= 110.percent
- }
- Detail "Girl likes how boy cums",
- description { "#{girl} likes how #{boy} cums" },
- available_for { M/F },
- when_cumming { |partner|
- if partner == boy then girl.time_until_cum_left = 10.percent * girl.time_until_cum; end
- }
- oalias :v => :PoseVariation
- # ---- Brool Stories, Inc. ----
- include StoryTelling
- story "Intrusion"
- "Welcome to Markov Geist. It's easy to forget that there have been other cities."[]
- lets_meet vixen "Kate_Windlight"
- Kate_Windlight.says "Hi Tactics. Your current task is to intrude Brightling
- University headquarters and to persuade its key figure, Eva Featherling,
- to our side."
- Kate_Windlight.says "Minor tacticians will handle the other staff and
- the security, so you will be able to concentrate on
- the Featherling directly."
- Kate_Windlight.says "You have 15 turns to convince her."
- "Intruder alert!"[]
- red_units =
- 20.of { |i| lets_meet male_fox "Civilian #{i+1}" } +
- 10.of { |i| lets_meet male_tiger "Guardian #{i+1}" } +
- [lets_meet lioness "Eva Featherling"]
- blue_units =
- 30.of { |i| lets_meet tigress "Unit #{i+1}" } +
- [lets_meet male_lion "Unit 31"]
- "TURN 1"[]
- plan = planning_phase! do
- (blue_units - [Unit_31]).zip(red_units - [Eva_Featherling]).each do |blue_unit, red_unit|
- [blue_unit, red_unit].reverse.yiff.in(Pose("Cowgirl") * v("Girl leans at the front and from behind")).at_most_for(15.minutes)
- end
- end
- plan.prime!
- "OUTCOME"[]
- red_units.delete_if do |red_unit|
- if red_unit.reminiscences.not_empty? and red_unit.reminiscences.last.partner[red_unit].satisfied? then
- log "#{red_unit} is ON OUR SIDE"
- true
- end
- end
- "TURN 2"[]
- plan = [Unit_31, Eva_Featherling].yiff.planning_phase!.
- # First I'll take control immediately.
- in(Pose("Boy on top") * v("Boy holding her hands") * v("They are kissing")).at_most_for(1.minute).
- # Then I'll loosen the grip for a while so she thinks that she still controls the situation...
- reset_details.in(Pose("Cowgirl") * v("Girl leans on his chest")).at_most_for(2.minutes).
- # ...but I should not relax.
- now(v("Boy holding breasts") * v("Her hands on his hands")).at_most_for(2.minutes).
- # Then I should take control to my hands again...
- then.reset_details.now.in(Pose("Boy on top") * v("Boy holding waist")).at_most_for(1.minute + 30.seconds).
- # ...to perform an attacking maneuver!
- in(Pose("Cunnilingus") * v("Boy holding hips") * v("Girl pushes his shoulders")).at_most_for(10.minutes).
- # Then I'll gracefully finish the battle.
- continue!.in(Pose("Boy on top") * v("Girl embraces him") * v("Girl embraces him with legs") * v("Boy holding waist")).at_most_for(5.minutes).
- then(v "They are kissing").do
- plan.prime!
- "OUTCOME"[]
- red_units.delete_if do |red_unit|
- if red_unit.reminiscences.not_empty? and red_unit.reminiscences.last.partner[red_unit].satisfied? then
- log "#{red_unit} is ON OUR SIDE"
- true
- end
- end
- if red_units.empty? then
- "***VICTORY***"[]
- "2 turns! 100 points! 1st place!"[]
- else
- "***LOSS***"[]
- "Better try another time."[]
- end
Add Comment
Please, Sign In to add comment