Class: Legion::Extensions::Agentic::Integration::Mosaic::Helpers::MosaicEngine

Inherits:
Object
  • Object
show all
Defined in:
lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ MosaicEngine

Returns a new instance of MosaicEngine.



10
11
12
13
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 10

def initialize
  @tesserae = {}
  @mosaics  = {}
end

Instance Method Details

#all_mosaics ⇒ Object 



99
100
101
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 99

def all_mosaics
  @mosaics.values
end

#all_tesserae ⇒ Object 



95
96
97
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 95

def all_tesserae
  @tesserae.values
end

#coherence(mosaic_id:) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 68

def coherence(mosaic_id:)
  mosaic = fetch_mosaic(mosaic_id)
  return 0.0 if mosaic.empty?

  placed = mosaic.tessera_ids.filter_map { |id| @tesserae[id] }
  return 0.0 if placed.empty?

  avg_fit = placed.sum(&:fit_quality) / placed.size
  grout_factor = mosaic.grout_strength
  ((avg_fit + grout_factor) / 2.0).clamp(0.0, 1.0).round(10)
end

#coherence_label(mosaic_id:) ⇒ Object 



80
81
82
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 80

def coherence_label(mosaic_id:)
  Constants.label_for(Constants::COHERENCE_LABELS, coherence(mosaic_id: mosaic_id))
end

#create_mosaic(name:, pattern_category:, capacity: 50, grout_strength: nil) ⇒ Object

Raises:

  • (ArgumentError) 


24
25
26
27
28
29
30
31
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 24

def create_mosaic(name:, pattern_category:, capacity: 50, grout_strength: nil)
  raise ArgumentError, 'mosaic limit reached' if @mosaics.size >= Constants::MAX_MOSAICS

  m = Mosaic.new(name: name, pattern_category: pattern_category,
                 capacity: capacity, grout_strength: grout_strength)
  @mosaics[m.id] = m
  m
end

#create_tessera(material:, domain:, content:, color: nil, fit_quality: nil) ⇒ Object

Raises:

  • (ArgumentError) 


15
16
17
18
19
20
21
22
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 15

def create_tessera(material:, domain:, content:, color: nil, fit_quality: nil)
  raise ArgumentError, 'tessera limit reached' if @tesserae.size >= Constants::MAX_TESSERAE

  t = Tessera.new(material: material, domain: domain, content: content,
                  color: color, fit_quality: fit_quality)
  @tesserae[t.id] = t
  t
end

#erode_all_grout!(rate: Constants::GROUT_DECAY) ⇒ Object 



44
45
46
47
48
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 44

def erode_all_grout!(rate: Constants::GROUT_DECAY)
  @mosaics.each_value { |m| m.erode_grout!(rate: rate) }
  crumbling = @mosaics.count { |_, m| m.crumbling? }
  { total: @mosaics.size, crumbling: crumbling }
end

#loose_tesserae ⇒ Object 



58
59
60
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 58

def loose_tesserae
  @tesserae.values.select(&:loose?)
end

#mosaic_report ⇒ Object 



84
85
86
87
88
89
90
91
92
93
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 84

def mosaic_report
  {
    total_tesserae:   @tesserae.size,
    total_mosaics:    @mosaics.size,
    loose_count:      loose_tesserae.size,
    by_material:      tesserae_by_material,
    crumbling_count:  @mosaics.count { |_, m| m.crumbling? },
    avg_completeness: avg_completeness
  }
end

#most_complete(limit: 5) ⇒ Object 



50
51
52
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 50

def most_complete(limit: 5)
  @mosaics.values.sort_by { |m| -m.completeness }.first(limit)
end

#most_gaps(limit: 5) ⇒ Object 



54
55
56
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 54

def most_gaps(limit: 5)
  @mosaics.values.sort_by { |m| -m.gap_count }.first(limit)
end

#place_tessera(tessera_id:, mosaic_id:) ⇒ Object

Raises:

  • (ArgumentError) 


33
34
35
36
37
38
39
40
41
42
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 33

def place_tessera(tessera_id:, mosaic_id:)
  tessera = fetch_tessera(tessera_id)
  mosaic  = fetch_mosaic(mosaic_id)

  raise ArgumentError, 'tessera already placed' if tessera.placed?
  raise ArgumentError, 'mosaic is full' if mosaic.full?

  mosaic.add_tessera(tessera_id)
  tessera.place!(mosaic_id)
end

#tesserae_by_material ⇒ Object 



62
63
64
65
66
 
# File 'lib/legion/extensions/agentic/integration/mosaic/helpers/mosaic_engine.rb', line 62

def tesserae_by_material
  counts = Constants::MATERIAL_TYPES.to_h { |m| [m, 0] }
  @tesserae.each_value { |t| counts[t.material] += 1 }
  counts
end