state_machines-mermaid 0.1.0

data/test/support/models/battle.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+# Epic battle scenario with multiple interacting state machines
+class Battle
+  attr_accessor :weather, :terrain, :advantage, :participants, :phase_start_time, :left_flank_secure,
+                :right_flank_secure
+
+  def initialize
+    @participants = {
+      dragons: [],
+      mages: [],
+      regiments: [],
+      heroes: []
+    }
+    @advantage = 50
+  end
+
+  state_machine :phase, initial: :preparation do
+    state :preparation do
+      def allow_reinforcements?
+        true
+      end
+    end
+
+    state :deployment do
+      def can_reposition?
+        true
+      end
+    end
+
+    state :skirmish do
+      def casualties_multiplier
+        0.5
+      end
+    end
+
+    state :main_battle do
+      def casualties_multiplier
+        2.0
+      end
+    end
+
+    state :climax do
+      def heroic_actions_enabled?
+        true
+      end
+    end
+
+    state :aftermath do
+      def battle_ended?
+        true
+      end
+    end
+
+    event :begin_deployment do
+      transition preparation: :deployment, if: :all_forces_ready?
+    end
+
+    event :commence_battle do
+      transition deployment: :skirmish
+    end
+
+    after_transition on: :commence_battle, to: :skirmish do |battle|
+      battle.phase_start_time = Time.now
+    end
+
+    event :escalate do
+      transition skirmish: :main_battle, if: -> { phase_duration > 300 || heavy_casualties? }
+    end
+
+    event :reach_climax do
+      transition main_battle: :climax, if: :decisive_moment?
+    end
+
+    event :conclude do
+      transition %i[skirmish main_battle climax] => :aftermath
+    end
+
+    after_transition any => any do |battle, transition|
+      battle.log_phase_change(transition)
+    end
+  end
+
+  # Weather conditions affecting battle
+  state_machine :weather, initial: :clear do
+    state :clear do
+      def visibility
+        1000
+      end
+    end
+
+    state :fog do
+      def visibility
+        100
+      end
+
+      def ranged_penalty
+        0.5
+      end
+    end
+
+    state :rain do
+      def movement_penalty
+        0.8
+      end
+
+      def fire_magic_penalty
+        0.6
+      end
+    end
+
+    state :storm do
+      def movement_penalty
+        0.5
+      end
+
+      def flying_impossible?
+        true
+      end
+    end
+
+    event :weather_change do
+      transition clear: %i[fog rain], if: :weather_front_approaching?
+      transition fog: %i[clear rain]
+      transition rain: %i[storm clear]
+      transition storm: :rain
+    end
+  end
+
+  # Battlefield control
+  state_machine :battlefield_control, initial: :contested do
+    state :contested
+    state :advantage_left
+    state :advantage_right
+    state :center_breakthrough
+    state :encirclement
+
+    event :gain_left do
+      transition contested: :advantage_left
+    end
+
+    event :gain_right do
+      transition contested: :advantage_right
+    end
+
+    event :breakthrough do
+      transition %i[advantage_left advantage_right] => :center_breakthrough
+    end
+
+    event :encircle do
+      transition %i[advantage_left advantage_right] => :encirclement, if: :flanks_secured?
+    end
+  end
+
+  def all_forces_ready?
+    participants.values.all? { |forces| forces.any?(&:ready?) }
+  end
+
+  def phase_duration
+    phase_start_time ? Time.now - phase_start_time : 0
+  end
+
+  def heavy_casualties?
+    total_casualties > initial_forces * 0.2
+  end
+
+  def decisive_moment?
+    advantage > 75 || advantage < 25
+  end
+
+  def log_phase_change(transition)
+    puts "Battle phase changed from #{transition.from} to #{transition.to}"
+  end
+
+  def weather_front_approaching?
+    rand(100) < 30
+  end
+
+  def flanks_secured?
+    @left_flank_secure && @right_flank_secure
+  end
+
+  def total_casualties
+    participants[:regiments].sum(&:casualties)
+  end
+
+  def initial_forces
+    @initial_forces ||= participants[:regiments].sum(&:soldiers)
+  end
+end

data/test/support/models/character.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# Base character class with complex state machine
+class Character
+  attr_accessor :health, :mana, :stamina, :experience, :level, :gold, :inventory
+
+  def initialize
+    @health = 100
+    @mana = 100
+    @stamina = 100
+    @experience = 0
+    @level = 1
+    @gold = 0
+    @inventory = []
+    super
+  end
+
+  state_machine :status, initial: :idle do
+    # Basic states
+    state :idle do
+      def currently_resting?
+        true
+      end
+    end
+
+    state :combat do
+      def in_danger?
+        true
+      end
+    end
+
+    state :casting do
+      def actively_casting?
+        true
+      end
+    end
+
+    state :resting do
+      def regenerating?
+        true
+      end
+    end
+
+    state :stunned do
+      def incapacitated?
+        true
+      end
+    end
+
+    state :dead do
+      def game_over?
+        true
+      end
+    end
+
+    # Complex transitions with conditions
+    event :engage do
+      transition idle: :combat, if: :can_fight?
+      transition resting: :combat, if: :interrupt_rest?
+      transition casting: :combat, unless: :spell_locked?
+    end
+
+    event :cast_spell do
+      transition %i[idle combat] => :casting, if: :has_mana?
+      transition casting: same, if: :channeling_spell?
+    end
+
+    event :rest do
+      transition %i[idle combat] => :resting, unless: :in_danger?
+      transition stunned: :resting, if: :recovered?
+    end
+
+    event :stun do
+      transition %i[idle combat casting] => :stunned
+    end
+
+    event :recover do
+      transition stunned: :idle, if: :stun_expired?
+      transition resting: :idle, if: :fully_rested?
+    end
+
+    event :die do
+      transition all - :dead => :dead
+    end
+
+    event :resurrect do
+      transition dead: :idle, if: :can_resurrect?
+    end
+
+    # Complex callbacks
+    before_transition on: :cast_spell do |char, transition|
+      char.mana -= calculate_mana_cost(transition)
+    end
+
+    after_transition to: :resting, &:start_regeneration
+
+    after_transition from: :casting, to: :idle, &:apply_spell_effects
+
+    around_transition on: :die do |char, _transition, block|
+      char.drop_items
+      block.call
+      char.notify_party
+      char.create_tombstone
+    end
+
+    # Guards would go here if using ActiveModel/ActiveRecord
+    # For plain Ruby objects, we handle validation in the condition methods
+  end
+
+  # Helper methods for conditions
+  def can_fight?
+    health.positive? && stamina > 10 && !incapacitated?
+  end
+
+  def has_mana?
+    mana >= 10
+  end
+
+  def channeling_spell?
+    @channeling_time&.positive?
+  end
+
+  def spell_locked?
+    @spell_lock_time && @spell_lock_time > Time.now
+  end
+
+  def in_danger?
+    false # Override in combat scenarios
+  end
+
+  def interrupt_rest?
+    true
+  end
+
+  def recovered?
+    @stun_duration && @stun_duration <= 0
+  end
+
+  def stun_expired?
+    recovered?
+  end
+
+  def fully_rested?
+    health == 100 && mana == 100
+  end
+
+  def can_resurrect?
+    level > 10 || has_resurrection_item?
+  end
+
+  def has_resurrection_item?
+    inventory.any? { |item| item.type == :resurrection }
+  end
+
+  def incapacitated?
+    false
+  end
+
+  def calculate_mana_cost(_transition)
+    10 # Base cost, can be overridden
+  end
+
+  def start_regeneration
+    @regenerating = true
+  end
+
+  def apply_spell_effects
+    # Apply any lingering spell effects
+  end
+
+  def drop_items
+    @dropped_items = inventory.dup
+    inventory.clear
+  end
+
+  def notify_party
+    # Notify party members
+  end
+
+  def create_tombstone
+    # Create memorial
+  end
+end

data/test/support/models/commander.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'character'
+
+# Commander class for regiment
+class Commander < Character
+  attr_accessor :leadership, :tactics, :inspiring
+
+  def initialize
+    super
+    @leadership = 75
+    @tactics = 80
+    @inspiring = true
+  end
+
+  def alive?
+    health.positive?
+  end
+
+  def with_regiment?
+    !status?(:absent)
+  end
+end

data/test/support/models/dragon.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative 'character'
+
+# Dragon with multiple parallel state machines
+class Dragon < Character
+  attr_accessor :rage, :treasure_hoard, :territory, :wingspan, :fire_breath_cooldown, :age, :last_meal_time, :injuries,
+                :current_target, :dive_distance, :devastation_score
+
+  def initialize
+    super
+    @rage = 0
+    @treasure_hoard = 1000
+    @territory = 100
+    @wingspan = 50
+    @fire_breath_cooldown = 0
+  end
+
+  # Mood state machine with states
+  state_machine :mood, initial: :sleeping, namespace: 'dragon' do
+    state :sleeping do
+      def snoring?
+        true
+      end
+
+      def alert_level
+        :minimal
+      end
+    end
+
+    # Sub-states would be separate state machines in state_machines gem
+    state :light_sleep
+    state :deep_sleep
+    state :hibernating
+
+    state :hunting do
+      def alert_level
+        :high
+      end
+
+      def speed_bonus
+        1.5
+      end
+    end
+
+    state :stalking
+    state :pursuing
+    state :feeding
+
+    state :hoarding do
+      def greed_multiplier
+        2.0
+      end
+
+      def treasure_sense_range
+        1000
+      end
+    end
+
+    state :rampaging do
+      def damage_multiplier
+        3.0
+      end
+
+      def fear_aura_range
+        500
+      end
+    end
+
+    # Complex event transitions
+    event :wake_up do
+      transition sleeping: :hunting, if: :hungry?
+      transition sleeping: :hoarding, if: :treasure_nearby?
+      transition light_sleep: :hunting
+      transition deep_sleep: :light_sleep
+      transition hibernating: :deep_sleep, if: :winter_ended?
+    end
+
+    event :find_treasure do
+      transition hunting: :hoarding
+      transition hoarding: same # Keep hoarding more
+      transition rampaging: :hoarding, if: -> { rage < 50 }
+    end
+
+    event :enrage do
+      transition any - :rampaging => :rampaging, if: -> { rage > 75 }
+    end
+
+    event :exhaust do
+      transition rampaging: :sleeping, if: -> { stamina <= 0 }
+      transition %i[hunting hoarding] => :sleeping, if: :tired?
+    end
+
+    # Callbacks with conditions
+    before_transition any => :rampaging do |dragon|
+      dragon.rage = 100
+      dragon.fire_breath_cooldown = 0
+    end
+
+    after_transition to: :hoarding, &:count_treasure
+
+    around_transition from: :rampaging do |dragon, _transition, block|
+      villages_before = dragon.nearby_villages.count
+      block.call
+      villages_after = dragon.nearby_villages.count
+      dragon.devastation_score += (villages_before - villages_after)
+    end
+  end
+
+  # Flight state machine
+  state_machine :flight, initial: :grounded do
+    state :grounded do
+      def can_dodge?
+        false
+      end
+    end
+
+    state :hovering do
+      def stability
+        0.8
+      end
+    end
+
+    state :soaring do
+      def speed
+        200
+      end
+    end
+
+    state :diving do
+      def attack_bonus
+        5.0
+      end
+    end
+
+    event :take_off do
+      transition grounded: :hovering, if: -> { stamina > 50 && !wing_injured? }
+    end
+
+    event :ascend do
+      transition hovering: :soaring, if: :weather_permits?
+      transition diving: :soaring
+    end
+
+    event :dive_attack do
+      transition %i[hovering soaring] => :diving, if: :target_spotted?
+    end
+
+    event :crash_land do
+      transition %i[hovering soaring diving] => :grounded
+    end
+
+    after_transition on: :crash_land, to: :grounded do |dragon|
+      dragon.take_damage(20)
+    end
+
+    event :land do
+      transition %i[hovering soaring] => :grounded
+      transition diving: :grounded, if: :dive_completed?
+    end
+  end
+
+  # Age progression state machine
+  state_machine :age_category, initial: :wyrmling do
+    state :wyrmling
+    state :young
+    state :adult
+    state :ancient
+    state :great_wyrm
+
+    event :age do
+      transition wyrmling: :young, if: -> { age >= 50 }
+      transition young: :adult, if: -> { age >= 200 }
+      transition adult: :ancient, if: -> { age >= 800 }
+      transition ancient: :great_wyrm, if: -> { age >= 1200 }
+    end
+  end
+
+  # Dragon-specific methods
+  def hungry?
+    @last_meal_time && (Time.now - @last_meal_time) > 86_400
+  end
+
+  def treasure_nearby?
+    sense_treasure_within(100)
+  end
+
+  def winter_ended?
+    Time.now.month.between?(3, 10)
+  end
+
+  def tired?
+    stamina < 30
+  end
+
+  def count_treasure
+    @treasure_hoard = calculate_hoard_value
+  end
+
+  def wing_injured?
+    @injuries&.include?(:wing)
+  end
+
+  def weather_permits?
+    !stormy? && visibility > 100
+  end
+
+  def target_spotted?
+    @current_target != nil
+  end
+
+  def dive_completed?
+    @dive_distance && @dive_distance <= 0
+  end
+
+  def take_damage(amount)
+    self.health -= amount
+  end
+
+  attr_reader :nearby_villages
+
+  def sense_treasure_within(_range)
+    false # Implement treasure detection
+  end
+
+  def calculate_hoard_value
+    treasure_hoard * greed_multiplier
+  end
+
+  def stormy?
+    false
+  end
+
+  def visibility
+    1000
+  end
+end