crate::ix!();
error_tree!{
pub enum GrowerModelWriteSkillTreeError {
Default,
}
}
pub trait SkillTreeCrateWriter {
type Error;
fn skill_tree_write_crate_text(&self) -> Result<String,Self::Error>;
}
impl SkillTreeCrateWriter for GrowerModel {
type Error = GrowerModelWriteSkillTreeError;
fn skill_tree_write_crate_text(&self) -> Result<String, Self::Error> {
use std::collections::{HashMap, HashSet, VecDeque};
info!("model = {:#?}", self);
let all_nodes = self.core_string_skeleton().top_down_nodes();
let mut node_map = HashMap::<String, CoreSkeletalNode>::new();
let mut referenced_childs = HashSet::<String>::new();
let mut leaf_holder_names = HashSet::<String>::new();
let mut dispatch_names = HashSet::<String>::new();
for n in all_nodes {
match &n {
CoreSkeletalNode::Dispatch(d) => {
dispatch_names.insert(d.name().clone());
referenced_childs.extend(d.children().iter().map(|c| c.name().clone()));
}
CoreSkeletalNode::Aggregate(a) => {
referenced_childs.extend(a.children().iter().map(|c| c.name().clone()));
}
CoreSkeletalNode::LeafHolder(lh) => {
leaf_holder_names.insert(lh.name().clone());
}
}
node_map.insert(n.name().clone(), n);
}
let mut roots: Vec<String> = node_map
.keys()
.filter(|name| !referenced_childs.contains(*name))
.cloned()
.collect();
roots.sort(); trace!(?roots, "identified crate‑emission roots");
let mut crate_text = String::new();
crate_text.push_str(
r#"// SPDX-License-Identifier: GPL-3.0-only
// This crate was generated by `capability` (GPLv3 licensed).
// This generated crate is explicitly licensed under GPLv3.
#![allow(unused_imports)]
#![allow(unused_variables)]
use std::fmt::Debug;
use serde::{Serialize, Deserialize};
use std::hash::Hash;
use tracing::*;
use variant_builder_macro::*;
use rand_construct::*;
use ai_descriptor::*;
use derive_builder::*;
use getset::*;
"#,
);
let mut entrypoint_type = roots[0].to_string();
let root_is_dispatch = matches!(
node_map.get(&entrypoint_type),
Some(CoreSkeletalNode::Dispatch(_))
);
let top_name = if root_is_dispatch {
format!("{entrypoint_type}Top")
} else {
entrypoint_type.clone()
};
let top_snake = top_name.to_snake_case();
let top_kebab = top_name.to_kebab_case();
crate_text.push_str(&formatdoc!(r#"
#[cfg(test)]
mod {top_snake}_test_suite {{
use super::*;
use traced_test::*;
use tracing_setup::*;
#[traced_test]
fn random_instantiation_test() {{
type This = {top_name};
let item = This::random();
println!("------------------------[random-{top_kebab}]");
(0..120).for_each(|_| println!("{{}}\n", This::random().ai()));
//assert!(false); // uncomment this assertion to see the results
}}
}}
"#));
if root_is_dispatch {
info!("installing dispatch abstraction layer to the top");
let inner_field = entrypoint_type.to_snake_case();
let child = node_map.get(&entrypoint_type).expect("child must exist when building variants");
let header_text = match child {
CoreSkeletalNode::Dispatch(dchild) => dchild.descriptor(),
CoreSkeletalNode::Aggregate(a) => a.descriptor(),
CoreSkeletalNode::LeafHolder(lh) => lh.descriptor(),
};
crate_text.push_str(&formatdoc! {r#"
#[derive(VariantBuilder,Debug, Clone, ItemWithFeatures, RandConstruct, Hash, PartialEq, Eq)]
pub enum {top_name} {{
#[default]
#[ai(wrap = "ItemWithFeatures")]
#[nested_builder]
#[ai(header_prefix="{header_text} ")]
{entrypoint_type}({entrypoint_type}),
}}
"#});
crate_text = crate_text.replace(
&format!("type This = {entrypoint_type};"),
&format!("type This = {top_name};"),
);
}
info!("about to emit nodes");
fn leaf_descriptor_for(
leaf_holder_name: &str,
leaf_name: &str,
expansions: &AnnotatedLeafHolderExpansions,
) -> String {
for holder in expansions.annotated_leaf_holders() {
if holder.leaf_holder_name() == leaf_holder_name {
for ann in holder.annotated_leaves() {
if ann.leaf_name() == leaf_name {
return ann.leaf_descriptor().to_string();
}
}
}
}
format!("No descriptor found for leaf '{leaf_name}'.")
}
let mut emitted = HashSet::<String>::new();
#[instrument(level = "trace", skip_all)]
fn emit_node(
name: &str,
node_map: &HashMap<String, CoreSkeletalNode>,
leaf_holder_names: &HashSet<String>,
dispatch_names: &HashSet<String>,
emitted: &mut HashSet<String>,
crate_text: &mut String,
model: &GrowerModel,
) {
if !emitted.insert(name.to_string()) {
trace!(node = name, "already emitted — skipping");
return;
}
let node = match node_map.get(name) {
Some(n) => n,
None => {
warn!(node = name, "child referenced but not found in map");
return;
}
};
debug!("emit_node, passed preliminary checks");
match node {
CoreSkeletalNode::Dispatch(d) => {
let mut variants = String::new();
for (idx, ch) in d.children().iter().enumerate() {
let child = node_map.get(ch.name())
.expect("child must exist when building variants");
if idx == 0 {
variants.push_str("#[default]\n");
}
match child {
CoreSkeletalNode::Dispatch(dchild) => {
variants.push_str(" #[ai(wrap = \"ItemWithFeatures\")]\n");
variants.push_str(" #[nested_builder]\n");
variants.push_str(&format!(
" #[ai(header_prefix = \"{} \")]\n",
dchild.descriptor()
));
}
CoreSkeletalNode::Aggregate(_) => {
variants.push_str(" #[ai(wrap = \"ItemWithFeatures\")]\n");
}
CoreSkeletalNode::LeafHolder(lh) => {
variants.push_str(" #[no_builder]\n");
variants.push_str(&format!(
" #[ai(\"{}\")]\n",
lh.descriptor()
));
}
}
variants.push_str(&format!(" {}({}),\n", ch.name(), ch.name()));
}
crate_text.push_str(&formatdoc!(
r#"
#[derive(VariantBuilder, Debug, Clone, ItemWithFeatures, RandConstruct, Hash, PartialEq, Eq)]
pub enum {ename} {{
{variants}
}}
"#,
ename = d.name(),
variants = variants.trim_end(),
));
}
CoreSkeletalNode::Aggregate(a) => {
let mut fields = String::new();
let mut found_opt_child = false;
for ch in a.children() {
let field_name = ch.name().to_case(Case::Snake);
let child = node_map.get(ch.name())
.expect("child must exist when building variants");
let child_descriptor = match child {
CoreSkeletalNode::Dispatch(dchild) => dchild.descriptor(),
CoreSkeletalNode::Aggregate(a) => a.descriptor(),
CoreSkeletalNode::LeafHolder(lh) => lh.descriptor(),
};
if *ch.optional() {
let p = *ch.probability() as f64 / 100.0;
let opt_header = match found_opt_child {
true => "No ",
false => "Specifically contains no ",
};
fields.push_str(&format!(
r#"
#[ai(feature_if_none="{opt_header}'{child}' module.")]
#[ai(feature_prefix_if_some="{child_descriptor} ")]
#[rand_construct(psome={prob})]
{field}: Option<{child}>,"#,
child = ch.name(),
prob = p,
field = field_name,
));
found_opt_child = true;
} else {
fields.push_str(&format!(
r#"
#[ai("{child_descriptor}")]
{field}: {child},"#,
child = ch.name(),
field = field_name,
));
}
}
crate_text.push_str(&formatdoc!(
r#"
#[derive(Builder, Debug, Clone, ItemWithFeatures, RandConstruct, Default, Hash, PartialEq, Eq, Getters)]
#[builder(pattern="owned", setter(into))]
#[ai("{desc}")]
pub struct {sname} {{
{fields}
}}
"#,
desc = a.descriptor(),
sname = a.name(),
fields = fields.trim_end(),
));
}
CoreSkeletalNode::LeafHolder(lh) => {
let mut variants = String::new();
for (idx, leaf) in lh.leaves().iter().enumerate() {
if idx == 0 {
variants.push_str("#[default]\n");
}
let ld = leaf_descriptor_for(
lh.name(),
leaf,
model.annotated_leaf_holder_expansions(),
);
variants.push_str(&format!(
" #[ai(\"{ld}\")]\n {leaf},\n",
ld = ld,
leaf = leaf
));
}
crate_text.push_str(&formatdoc!(
r#"
#[derive(Debug, Clone, ItemFeature, RandConstruct, Default, Hash, PartialEq, Eq)]
pub enum {ename} {{
{variants}
}}
"#,
ename = lh.name(),
variants = variants.trim_end(),
));
}
}
}
let mut queue: VecDeque<String> = roots.into_iter().collect();
while let Some(current) = queue.pop_front() {
debug!("processing {:#?}", current);
emit_node(
¤t,
&node_map,
&leaf_holder_names,
&dispatch_names,
&mut emitted,
&mut crate_text,
self,
);
debug!("emit_node terminated");
if let Some(node) = node_map.get(¤t) {
match node {
CoreSkeletalNode::Dispatch(d) => {
debug!("processing Dispatch node {:#?}", d);
for ch in d.children() {
if !emitted.contains(ch.name()) {
queue.push_back(ch.name().clone());
}
}
}
CoreSkeletalNode::Aggregate(a) => {
debug!("processing Aggregate node {:#?}", a);
for ch in a.children() {
if !emitted.contains(ch.name()) {
queue.push_back(ch.name().clone());
}
}
}
CoreSkeletalNode::LeafHolder(lh) => {
debug!("processing LeafHolder node {:#?}", lh);
}
}
}
}
Ok(crate_text)
}
}
#[cfg(test)]
mod grower_model_tests {
use super::*;
#[traced_test]
async fn basic_smoke() -> Result<(),GrowerModelWriteSkillTreeError> {
let mut map = HashMap::<&'static str, &[&'static str]>::default();
map.insert("foxes", &[
"fox-advanced-social-group-coordination-and-complex-cooperative-task-execution",
"fox-performance-conditioning-for-speed-and-endurance",
"fox-advanced-performance-design-and-precision-task-choreography-mastery",
"fox-initial-directional-cue-response-training-to-basic-verbal-and-hand-gestures",
"fox-basic-den-and-resting-area-familiarization-and-conditioning",
"fox-basic-target-following-over-short-distances-and-simple-pathways",
"fox-social-group-coordination-and-cooperative-task-conditioning",
"fox-simple-habitat-maintenance-and-comfort-management-awareness",
"fox-long-duration-station-holding-and-task-performance-under-significant-distractions",
"fox-positive-food-reward-conditioning-with-precise-delivery-timing",
"fox-performance-prop-interaction-techniques",
"fox-soft-vocal-tone-and-human-voice-conditioning-for-trust-building",
"fox-positive-reinforcement-training-techniques",
"fox-object-manipulation-under-forest-conditions",
"fox-advanced-object-manipulation-in-forest-settings",
"fox-basic-station-area-familiarization-and-short-duration-conditioning",
"fox-target-tracking-through-variable-terrain",
"fox-positive-food-association-conditioning-with-human-interaction",
"fox-basic-agility-and-precision-foot-placement-training-over-low-obstacles",
"fox-social-performance-cue-responsiveness",
"fox-station-duration-extension-up-to-3-minutes-under-controlled-distractions",
"fox-stress-reduction-and-socialization-methods",
"fox-highly-precise-target-following-and-navigation-through-challenging-and-variable-environments",
"fox-controlled-introduction-to-minimal-environmental-distractions-and-stimuli",
"fox-complex-directional-cue-response-with-combined-visual-verbal-and-tactile-signals",
"fox-target-identification-and-tracking-skills",
"fox-advanced-territorial-navigation-resource-management-and-boundary-recognition-training",
"fox-intermediate-agility-course-navigation-with-complex-terrain-and-obstacles",
"fox-agility-and-performance-cue-mastery",
"fox-advanced-object-manipulation-tool-use-and-complex-task-performance-conditioning",
"fox-station-duration-training-starting-from-15-to-45-seconds",
"fox-simple-social-presence-conditioning-with-multiple-handlers-and-conspecifics",
"fox-extended-target-following-and-navigation-over-complex-and-variable-terrain",
"fox-gradual-human-presence-desensitization-through-controlled-proximity-management",
"fox-adaptive-responsiveness-to-sophisticated-multi-modal-command-sequences",
"fox-initial-observation-of-stress-and-relaxation-body-language-signals",
"fox-simple-object-touch-retrieval-and-target-response-conditioning",
"fox-controlled-conditioning-to-low-intensity-environmental-distractions",
"fox-precision-object-manipulation-placement-and-sequential-task-training",
"fox-comprehensive-emotional-and-stress-state-monitoring-for-optimal-engagement",
"fox-agility-course-vertical-scaling",
"fox-basic-grooming-health-inspection-and-handling-desensitization",
"fox-responsiveness-conditioning-to-subtle-human-body-language-and-gesture-cues",
"fox-positive-reward-frequency-and-type-optimization-for-task-complexity",
"fox-initial-scent-familiarization-and-positive-object-association",
"fox-comprehensive-problem-solving-adaptive-behavior-and-task-sequencing-conditioning",
"fox-extended-grooming-handling-and-comprehensive-health-examination-conditioning",
"fox-group-social-coordination-techniques",
"fox-advanced-agility-course-precision-training",
"fox-extended-performance-of-complex-sequential-behavioral-tasks-with-memory-retention",
"fox-controlled-introduction-to-basic-hand-proximity-and-gentle-touch",
"fox-basic-eye-contact-duration-awareness-and-conditioning",
"fox-group-social-cue-training",
"fox-agility-course-navigation-with-complex-obstacles",
"fox-advanced-object-discrimination-training",
"fox-targeted-enrichment-exercise-regimens",
"fox-controlled-conditioning-to-moderate-environmental-and-social-distractions",
"fox-social-hierarchy-performance-management",
]);
map.insert("real-estate", &[
"real-estate-72-hour-clause-contingent-sale-risk-management",
"real-estate-abstract-of-title-verification-and-analysis",
"real-estate-acceleration-clause-default-risk-management",
"real-estate-accession-property-rights-clarification",
"real-estate-acreage-measurement-and-land-valuation",
"real-estate-ad-valorem-property-tax-management",
"real-estate-adjustable-rate-mortgage-risk-mitigation",
"real-estate-adjusted-basis-capital-gain-calculation",
"real-estate-adverse-possession-property-rights-defense",
"real-estate-affordable-housing-investment-and-social-impact-strategy",
"real-estate-agency-transaction-representation-management",
"real-estate-agent-transaction-facilitation-management",
"real-estate-air-rights-acquisition-and-utilization",
"real-estate-alluvion-and-accretion-property-boundary-management",
"real-estate-american-land-title-association-compliance",
"real-estate-amortizing-loan-management-and-strategy",
"real-estate-anchor-store-commercial-investment-strategy",
"real-estate-annexation-and-zoning-impact-management",
"real-estate-annual-percentage-rate-cost-assessment",
"real-estate-anti-money-laundering-compliance-and-risk-management",
"real-estate-apartment-investment-analysis-and-management",
"real-estate-appraisal-property-valuation-strategy",
"real-estate-appraisal-standards-professional-compliance",
"real-estate-appraised-value-assessment-and-validation",
"real-estate-appurtenant-easement-rights-and-valuation",
"real-estate-arms-length-transaction-principle-compliance",
"real-estate-arrears-debt-collection-and-management",
"real-estate-asking-price-negotiation-strategy",
"real-estate-asset-identification-and-financial-resource-management",
"real-estate-assignment-law-contractual-rights-transfer",
"real-estate-assumption-of-mortgage-transaction-management",
"real-estate-attorney-at-law-transaction-and-legal-protection",
"real-estate-attorney-in-fact-financial-authority-management",
"real-estate-avulsion-property-boundary-risk-management",
"real-estate-balance-sheet-preparation-and-financial-reporting",
"real-estate-balloon-mortgage-structure-and-risk-management",
"real-estate-bargain-and-sale-deed-risk-clarification",
"real-estate-benchmarking-investment-performance-management",
"real-estate-beneficiary-rights-and-management",
"real-estate-bequest-property-transfer-and-legacy-planning",
"real-estate-bilateral-contract-management-and-enforcement",
"real-estate-bill-of-sale-documentation-and-transfer-management",
"real-estate-blanket-loan-portfolio-financing-strategy",
"real-estate-blockchain-title-transfer-and-risk-management",
"real-estate-boiler-insurance-coverage-and-risk-management",
"real-estate-bona-fide-purchaser-rights-and-protection",
"real-estate-book-value-calculation-and-valuation-management",
"real-estate-boot-property-exchange-and-tax-management",
"real-estate-boundary-determination-and-dispute-resolution",
"real-estate-bpo-standards-and-guidelines-compliance",
"real-estate-broker-transaction-integrity-management",
"real-estate-brokerage-market-access-management",
"real-estate-brokers-price-opinion-valuation-and-compliance",
"real-estate-bubble-market-risk-awareness",
]);
map.insert("zoosemiosis", &[
"zoosemiotic-danger-safety-alarm-calls-and-predator-response-training",
"zoosemiotic-danger-safety-context-driven-symbolic-learning-and-adaptation",
"zoosemiotic-danger-safety-cross-species-threat-recognition-and-signaling",
"zoosemiotic-danger-safety-minimal-ambiguity-and-rapid-sign-processing-training",
"zoosemiotic-danger-safety-risk-assessment-and-group-vigilance-pattern-recognition",
"zoosemiotic-family-social-bonds-cooperation-conflict-and-reconciliation-pattern-training",
"zoosemiotic-family-social-bonds-minimal-symbolic-density-in-social-maintenance-signals",
"zoosemiotic-family-social-bonds-parent-offspring-signaling-patterns",
"zoosemiotic-family-social-bonds-social-affiliation-and-hierarchy-sign-recognition",
"zoosemiotic-food-nourishment-cross-species-competition-and-cooperation-signals",
"zoosemiotic-food-nourishment-foraging-and-feeding-sign-pattern-recognition",
"zoosemiotic-food-nourishment-group-coordination-in-hunting-and-gathering",
"zoosemiotic-food-nourishment-resource-availability-and-minimal-sign-density-calibration",
"zoosemiotic-food-nourishment-symbolic-social-learning-and-cultural-transmission",
"zoosemiotic-life-death-affiliative-behavior-during-distress-events",
"zoosemiotic-life-death-alarm-signal-pattern-analysis",
"zoosemiotic-life-death-alarm-signal-pattern-analysis2",
"zoosemiotic-life-death-minimal-energy-signaling-and-survival-patterns",
"zoosemiotic-life-death-ritualized-behavior-and-social-learning-calibration",
"zoosemiotic-life-death-symbolic-recognition-in-animal-behavior",
"zoosemiotic-motion-rest-cross-species-symbolic-motion-pattern-calibration",
"zoosemiotic-motion-rest-group-movement-coordination-and-minimal-energy-signals",
"zoosemiotic-motion-rest-locomotion-patterns-and-symbolic-social-signals",
"zoosemiotic-motion-rest-predator-and-prey-chase-pattern-symbol-recognition",
"zoosemiotic-motion-rest-resting-state-and-social-relaxation-sign-recognition",
"zoosemiotic-sun-moon-circadian-rhythm-and-signal-pattern-calibration",
"zoosemiotic-sun-moon-cross-species-temporal-signaling-optimization",
"zoosemiotic-sun-moon-minimal-density-energy-expenditure-calibration",
"zoosemiotic-sun-moon-nocturnal-and-diurnal-behavior-pattern-recognition",
"zoosemiotic-sun-moon-seasonal-migration-and-navigation-signal-analysis",
"zoosemiotic-time-space-cross-species-territorial-dispute-resolution-signals",
"zoosemiotic-time-space-home-range-recognition-and-spatial-symbolic-cognition",
"zoosemiotic-time-space-minimal-density-symbolic-navigation-training",
"zoosemiotic-time-space-navigation-patterns-and-migratory-route-symbols",
"zoosemiotic-time-space-territorial-signaling-and-boundary-recognition",
]);
map.insert("owl", &[
"owl-adaptive-responsiveness-to-highly-sophisticated-multi-modal-command-sequences",
"owl-advanced-flight-pattern-choreography",
"owl-advanced-object-manipulation-and-complex-task-performance-conditioning",
"owl-advanced-performance-design-and-precision-flight-choreography-mastery",
"owl-advanced-problem-solving-adaptive-behavior-and-flight-sequencing-conditioning",
"owl-basic-eye-contact-duration-awareness-and-conditioning",
"owl-basic-flight-agility-and-navigation-conditioning-over-low-level-obstacles",
"owl-basic-health-inspection-handling-and-equipment-desensitization",
"owl-basic-observation-of-stress-and-relaxation-body-language-signals",
"owl-basic-station-area-familiarization-and-short-duration-conditioning",
"owl-basic-target-following-over-short-distances-and-simple-flight-paths",
]);
map.insert("adaptive-technology", &[
"active-camouflage-metamaterial-optical-field-adaptation-training",
"adaptive-biomechanical-control-algorithm-human-integration-calibration",
"adaptive-camouflage-field-integrated-microelectronics-optimization",
"adaptive-composite-armor-dynamic-stiffness-response-calibration",
"adaptive-drone-network-minimal-communication-latency-calibration",
"adaptive-exoskeleton-predictive-biomechanical-interface-training",
"adaptive-medical-response-minimal-human-intervention-calibration",
"adaptive-reaction-control-micro-scale-thruster-precision",
"adaptive-thermal-management-for-high-energy-portable-devices",
"additive-manufacturing-complex-metamaterial-precision-training",
"advanced-augmented-reality-hud-and-sensor-fusion-training",
"advanced-cryostasis-vitrification-and-cellular-integrity-preservation",
"advanced-field-medical-kit-ai-driven-autonomous-diagnosis",
"advanced-gravitational-field-manipulation-and-frame-dragging-control",
"advanced-materials-flexible-armor-and-metamaterial-engineering",
"advanced-medical-biofoam-hemostatic-and-tissue-regeneration",
"advanced-microfusion-direct-electrical-energy-conversion",
"ai-driven-nanomachine-coordination-and-autonomous-repair-training",
"antigravity-device-minimal-gravitational-distortion-calibration",
"autonomous-adaptive-combat-vehicle-sensor-degradation-tolerance",
"autonomous-nanoscale-molecular-manufacturing-training",
"autonomous-robotic-assembly-complex-structures-optimization",
"autonomous-vehicle-combat-decision-making-and-tactical-autonomy",
"biocompatible-neural-implant-long-term-stability-calibration",
"biomechanical-predictive-algorithms-for-armor-mobility-optimization",
"compact-directed-energy-weapon-miniaturization-and-efficiency-training",
"compact-fusion-reactor-energy-density-and-confinement-optimization",
"compact-life-support-environmental-control-system-calibration",
"compact-particle-accelerator-miniaturization-and-field-control",
"composite-material-integrity-under-extreme-condition-calibration",
"cryopreservation-vitrification-cellular-integrity-optimization",
"distributed-autonomous-vehicle-communication-robustness-calibration",
"drone-swarm-tactical-coordination-and-autonomous-control",
"dynamic-structural-health-monitoring-system-feedback-calibration",
"exoskeleton-neural-integration-with-minimal-latency-optimization",
"functional-metamaterial-cloaking-infrared-and-radar-invisibility-calibration",
"hard-light-field-generation-with-electromagnetic-force-feedback",
"high-density-information-storage-and-quantum-state-encoding",
"high-density-neuromorphic-computing-architecture-calibration",
"high-density-ultracapacitor-energy-release-and-storage-optimization",
"high-efficiency-electromagnetic-propulsion-and-energy-transfer",
"high-efficiency-plasma-generation-portable-device-optimization",
"high-energy-rifle-containment-field-density-calibration",
"high-frequency-directed-energy-field-density-calibration",
"high-temperature-superconducting-magnet-field-density-calibration",
"high-temperature-superconductor-miniaturization-and-field-density-calibration",
"hybrid-electric-propellant-thruster-miniaturization-and-efficiency-calibration",
"hybrid-quantum-classical-computational-architecture-integration",
"individual-precision-controlled-aerobraking-and-landing-algorithms",
"individual-scale-precision-heat-shielding-for-reentry-training",
"infantry-scale-electromagnetic-cloaking-field-optimization",
"instantaneous-neural-encoding-and-decoding-algorithms",
"integrated-eye-tracking-and-real-time-object-recognition",
"integrated-holographic-display-resolution-and-accuracy-calibration",
"low-latency-neural-feedback-for-combat-enhancement-training",
"low-power-edge-computing-sensor-fusion-density-optimization",
"micro-fusion-reactor-prototype-net-positive-energy-output-calibration",
"micro-scale-thermal-management-for-high-density-devices",
"microfluidic-on-demand-drug-synthesis-and-delivery-precision",
"microfluidic-on-demand-pharmaceutical-synthesis-precision-calibration",
"miniature-thruster-reaction-control-and-aerodynamic-calibration",
]);
map.insert("electronic-music", &[
"adaptive-ambient-space-design",
"adaptive-attack-release-envelope",
"adaptive-attack-release-tail-modeling",
"adaptive-binaural-beat-generation",
"adaptive-binaural-room-modeling",
"adaptive-biofeedback-frequency-design",
"adaptive-bowed-string-harmonics",
"adaptive-brainwave-phase-locking",
"adaptive-build-break-energy-control",
"adaptive-chop-density-control",
"adaptive-crossfade-loop-blending",
]);
map.insert("river-town", &[
"alleyway-agility",
"amphibious-combat-tactics",
"animal-flow",
"aquatic-grappling",
"balance",
"bar-fighting",
"boxing",
"breakdancing",
"breathwork",
"bushcraft",
"calisthenics",
"camouflage",
"canoeing",
"capoeira",
"close-quarters-combat",
"cobblestone-street-running",
"cold-water-conditioning",
"docs",
"evasion",
"fire-environment-qigong",
"fishing",
"forest-based-archery",
"forest-orienteering",
"forest-slacklining",
"guerrilla-combat-tactics",
"gymnastics",
"historic-meditation",
"historic-urban-bushcraft",
"historical-archery",
"historical-european-martial-arts",
"historical-site-yoga",
"hydrotherapy",
"ice-fishing",
"improvised-combat",
"jedi-mind-tricks",
"judo",
"knife-fighting",
"knife-throwing",
"krav-maga",
"lockpicking",
"love",
"medieval-calisthenics",
"meditation",
"mouvement-naturel",
"natural-movement",
"parkour",
"patch-bay",
"pilates",
"primitive-fish-trapping",
"primitive-hunting",
"qigong",
"quigong",
"rafting",
"river-crossing-techniques",
"river-running",
"river-swimming",
"riverbank-bushcraft",
"riverside-balance-training",
"riverside-yoga",
"rooftop-traversal",
"sanskrit-yoga",
"snow-love",
"snow-love-building",
"snow-love-building-advanced",
"snow-love-building-masterful",
"snow-love-campfire",
"spearfishing",
"stealth-movement",
"swiftwater-parkour",
"swiftwater-rescue",
"tai-chi",
"target",
"trail-running",
"trapping",
"tree-climbing",
"urban-entry-techniques",
"urban-foraging",
"urban-historical-parkour",
"urban-slacklining",
"urban-stealth",
"waterborne-archery",
"watercraft-construction",
"whitewater-kayaking",
"wilderness-first-aid",
"woodland-yoga",
"yoga-sanskrit",
]);
let generated_skill_tree_workspaces_dir = "generated-skill-tree-workspaces";
let do_these = [
"river-town",
];
for (workspace_key, workspace_set) in map.iter() {
if !do_these.is_empty() && !do_these.contains(workspace_key) {
continue;
}
let mut set_members = vec![];
for name in workspace_set.iter() {
if let Ok(model)
= GrowerModel::load_from_file(format!("../patch-bay/{name}.json"))
.await
{
let crate_text = model.skill_tree_write_crate_text()?;
let cargo_toml_text = formatdoc!{
r#"
[package]
name = "{name}"
license = "GPL-3.0-only"
license-text = "LICENSE"
authors = ["klebs6 <tpk3.mx@gmail.com>"]
version = "0.1.0"
edition = "2024"
description = "Skill tree crate for the {name} system."
keywords = ["grower", "skill", "tree", "simulation", "generator"]
categories = ["simulation"]
[dependencies]
ai-descriptor.workspace = true
ai-descriptor-derive.workspace = true
export-magic.workspace = true
once_cell.workspace = true
rand.workspace = true
derive_builder.workspace = true
getset.workspace = true
tracing.workspace = true
tracing-setup.workspace = true
traced-test.workspace = true
serde.workspace = true
variant-builder-macro.workspace = true
rand-construct.workspace = true
"#};
let license_text = formatdoc!{
r#"Licensed under GPLv3. Downstream generation byproducts inherit GPLv3."#
};
std::fs::create_dir_all(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/src")).expect("expected create dir success");
std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/src/lib.rs"), crate_text).expect("we expected to be able to write this file");
std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/Cargo.toml"), cargo_toml_text).expect("we expected to be able to write the Cargo.toml");
std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/{name}/LICENSE"), license_text).expect("we expected to be able to write the SPPL license file");
set_members.push(name);
} else {
warn!("expected to unpack this file ../patch-bay/{name}.json");
}
}
let workspace_cargo_toml_text = formatdoc! {
r#"
[workspace]
members = [
{members}
]
[workspace.dependencies]
ai-descriptor = {{ version = "0.11.0", path = "/Users/kleb/bethesda/work/repo/klebs-general/ai-descriptor" }}
ai-descriptor-derive = {{ version = "0.6.0", path = "/Users/kleb/bethesda/work/repo/klebs-general/ai-descriptor-derive" }}
derive_builder = "0.20.2"
export-magic = "0.3.6"
getset = "0.1.4"
once_cell = "1.20.2"
rand = "0.8.5"
rand-construct = {{ version = "0.14.0", path = "/Users/kleb/bethesda/work/repo/klebs-general/rand-construct" }}
serde = "1.0.219"
traced-test = {{ version = "1.0.3", path = "/Users/kleb/bethesda/work/repo/klebs-general/traced-test" }}
tracing = "0.1.41"
tracing-setup = {{ version = "1.0.3", path = "/Users/kleb/bethesda/work/repo/klebs-general/tracing-setup" }}
variant-builder-macro = {{ version = "0.3.0", path = "/Users/kleb/bethesda/work/repo/klebs-general/variant-builder-macro" }}
"#,
members = set_members
.iter()
.map(|name| format!(" \"{name}\""))
.collect::<Vec<_>>()
.join(",\n")
};
let workspace_makefile_text = formatdoc! {
r#"
.PHONY: build active test run test_all
ENTRYPOINT := {workspace_key}
#RUSTFLAGS := "-Awarnings -Z time-passes"
RUSTFLAGS := -Awarnings RUST_BACKTRACE=1
#CARGO := env CARGO_MSG_LIMIT=15 CARGO_BUILD_JOBS=12 NUM_JOBS=12 cargo
CARGO := MAKEFLAGS= env CARGO_BUILD_JOBS=12 NUM_JOBS=12 cargo
BUILD := build --verbose
RUN := run
TEST := test
ACTIVE_PACKAGE := {first_package_name}
DEFAULT := test_all
#DEFAULT := test
#DEFAULT := build
#FEATURES := --features "enable_stress_test"
FEATURES := --features ""
default: $(DEFAULT)
#NOCAPTURE := --nocapture
#NOCAPTURE :=
#----------------------------------------------[here are our rules]
run:
RUSTFLAGS=$(RUSTFLAGS) $(CARGO) run -p $(ACTIVE_PACKAGE) --bin $(ENTRYPOINT) $(FEATURES)
build:
RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(BUILD) $(FEATURES)
active:
RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(BUILD) -p $(ACTIVE_PACKAGE) $(FEATURES)
test:
RUST_MIN_STACK=8388608 RUST_LOG=trace RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(TEST) -p $(ACTIVE_PACKAGE) -- $(NOCAPTURE)
test_all:
RUSTFLAGS=$(RUSTFLAGS) $(CARGO) $(TEST) --workspace -- $(NOCAPTURE)
"#,
first_package_name = set_members[0],
workspace_key = workspace_key
}.replace("\n ", "\n\t");
std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/Cargo.toml"), workspace_cargo_toml_text).expect("we expected to be able to write the workspace Cargo.toml");
std::fs::write(format!("../{generated_skill_tree_workspaces_dir}/{workspace_key}/Makefile"), workspace_makefile_text).expect("we expected to be able to write the workspace Makefile");
}
Ok(())
}
}