use super::{
Goal, Guide, GuideCategory, MeetKind, StartingState,
build_text::{
IndicesText, Role, angle_text, indices_text, infer_roles, mast_text, teaching_names,
},
is_valid_guide_id,
model::BUILD_ID_PREFIX,
rebuilt::{MAST_FLOOR, mast_within},
steps::{TIER_STEP, TIER_STEP_EXACT},
};
use crate::loading::{TierFormFields, parse_tier_form};
use indicatrix::geometry::meet_solver::{
Block, MeetConstraint, SolveStrategy, SolvedTier, classify_blocks,
};
use indicatrix_cut_core::{ConstraintTier, Design, design::TierRef};
use std::fmt;
mod step_builders;
use step_builders::{compare_step, final_step, lesson_steps, solve_step, start_step};
pub const BUILD_TITLE_PREFIX: &str = "Build ";
pub const START_STEP_TITLE: &str = "Start a new design";
pub const SOLVE_STEP_TITLE: &str = "Solve and check";
pub const COMPARE_STEP_TITLE: &str = "Compare with the original";
pub const LARGE_DESIGN_TIERS: usize = 40;
pub const MAX_TIERS_PER_STEP: usize = 6;
pub const REBUILD_ANGLE_TOL_DEG: f64 = 0.02;
pub const REBUILD_MAST_REL_TOL: f64 = 0.01;
const VERIFY_MAST_REL_TOL: f64 = 0.004;
const MAX_VERIFY_ROUNDS: usize = 3;
const MAX_MEET_TIERS: usize = 60;
const BOOKEND_STEPS: usize = 4;
const DIALOG_GEARS: [u32; 6] = [96, 80, 77, 72, 64, 120];
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BuildGuideError {
NoTiers,
NoUsableMasts,
DoesNotSolve(String),
BadKey,
CannotTeach(String),
NotFit(String),
}
impl fmt::Display for BuildGuideError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NoTiers => f.write_str("This design has no flat tiers to rebuild."),
Self::NoUsableMasts => f.write_str(
"This design only has placeholder depths (every depth is zero), so there is \
nothing to rebuild it from.",
),
Self::DoesNotSolve(reason) => write!(
f,
"This design does not solve, so a lesson could not check the rebuild: {reason}"
),
Self::BadKey => f.write_str("This design has no usable library key for a lesson."),
Self::CannotTeach(reason) => write!(
f,
"A tier of this design cannot be typed into the tier form: {reason}"
),
Self::NotFit(reason) => write!(f, "The lesson could not be built: {reason}"),
}
}
}
impl std::error::Error for BuildGuideError {}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TierRecipe {
pub name: String,
pub angle: String,
pub indices: String,
pub constraint_kind: i32,
pub constraint_text: String,
}
impl TierRecipe {
#[must_use]
pub fn fields(&self, gear_teeth_abs: u32, other_tier_names: Vec<String>) -> TierFormFields<'_> {
TierFormFields {
angle: &self.angle,
constraint_kind: self.constraint_kind,
constraint_text: &self.constraint_text,
name: &self.name,
indices: &self.indices,
gear_teeth_abs,
imported_meet: None,
original_notes: None,
other_tier_names,
}
}
}
#[derive(Clone, Debug)]
pub struct BuildPlan {
pub guide: Guide,
pub recipes: Vec<TierRecipe>,
pub original_positions: Vec<usize>,
}
#[derive(Clone, Copy, Debug)]
pub struct ReferenceDesign<'a> {
pub design: &'a Design,
pub masts: &'a [f64],
}
#[must_use]
pub fn reference_design(guide: &Guide) -> Option<ReferenceDesign<'_>> {
if !is_build_guide_id(&guide.id) {
return None;
}
guide.steps.iter().find_map(|step| find_rebuilt(&step.goal))
}
fn find_rebuilt(goal: &Goal) -> Option<ReferenceDesign<'_>> {
match goal {
Goal::DesignRebuilt {
target,
target_masts,
..
} => Some(ReferenceDesign {
design: target,
masts: target_masts,
}),
Goal::All(goals) | Goal::Any(goals) => goals.iter().find_map(find_rebuilt),
_ => None,
}
}
#[must_use]
pub fn is_build_guide_id(id: &str) -> bool {
id.starts_with(BUILD_ID_PREFIX)
}
#[must_use]
pub fn build_guide_id(design_key: &str) -> String {
format!("{BUILD_ID_PREFIX}{design_key}")
}
#[must_use]
pub fn is_compare_step(guide: &Guide, index: usize) -> bool {
is_build_guide_id(&guide.id)
&& guide
.steps
.get(index)
.is_some_and(|step| step.title == COMPARE_STEP_TITLE)
}
#[must_use]
pub fn original_label(guide: &Guide) -> String {
let title = guide
.title
.strip_prefix(BUILD_TITLE_PREFIX)
.unwrap_or(&guide.title);
format!("Original: {title}")
}
pub fn build_this_design_guide(
target: &Design,
solved: Option<&[SolvedTier]>,
source_title: &str,
design_key: &str,
) -> Result<Guide, BuildGuideError> {
build_this_design_plan(target, solved, source_title, design_key).map(|plan| plan.guide)
}
pub fn build_this_design_plan(
target: &Design,
solved: Option<&[SolvedTier]>,
source_title: &str,
design_key: &str,
) -> Result<BuildPlan, BuildGuideError> {
let id = build_guide_id(design_key);
if !is_valid_guide_id(&id) {
return Err(BuildGuideError::BadKey);
}
if target.tiers.is_empty() {
return Err(BuildGuideError::NoTiers);
}
let masts = target_masts(target, solved)?;
let blocks = classify_blocks(&target.meet_tier_inputs());
let names = teaching_names(&target.tiers, &blocks);
let roles = infer_roles(&target.tiers, &names, &blocks);
let order = flat_order(target);
let facts = TierFacts {
blocks,
names,
roles,
masts,
};
let mut plan = plan_tiers(target, &facts, &order);
verify_meets(target, &mut plan)?;
let title = display_title(source_title);
let mut steps = lesson_steps(target, &plan);
let step_count = steps.len() + BOOKEND_STEPS;
steps.insert(0, start_step(target, &title, step_count));
steps.push(solve_step());
steps.push(compare_step(target, &facts));
steps.push(final_step(target, &title));
let flat = plan.len();
let mut guide = Guide::new(
id,
format!("{BUILD_TITLE_PREFIX}{title}"),
format!(
"Rebuild {title} from an empty design, {flat} {} in cutting order, then compare it \
with the original.",
if flat == 1 { "tier" } else { "tiers" }
),
GuideCategory::BuildThisDesign,
)
.starting(StartingState::CurrentDesign);
guide.steps = steps;
if let Some(problem) = guide.problem() {
return Err(BuildGuideError::NotFit(problem));
}
Ok(BuildPlan {
guide,
recipes: plan.iter().map(|tier| tier.recipe.clone()).collect(),
original_positions: order,
})
}
fn display_title(source_title: &str) -> String {
let title = source_title.trim();
if title.is_empty() {
"this design".to_owned()
} else {
title.to_owned()
}
}
fn target_masts(
target: &Design,
solved: Option<&[SolvedTier]>,
) -> Result<Vec<f64>, BuildGuideError> {
let pinned = target.tier_targets.is_empty()
&& target
.tiers
.iter()
.all(|tier| matches!(tier.constraint, MeetConstraint::ScaleReference(_)));
let masts = match solved.filter(|solved| solved.len() == target.tiers.len()) {
Some(solved) => solved_depths(solved)?,
None if pinned => target
.tiers
.iter()
.map(|tier| match tier.constraint {
MeetConstraint::ScaleReference(value) => value,
_ => 0.0,
})
.collect(),
None => {
let solved = target
.solve()
.map_err(|error| BuildGuideError::DoesNotSolve(error.to_string()))?;
solved_depths(&solved)?
}
};
if masts.iter().any(|mast| !mast.is_finite()) {
return Err(BuildGuideError::DoesNotSolve(
"a depth is not a number.".to_owned(),
));
}
if masts.iter().all(|mast| mast.abs() < 1e-9) {
return Err(BuildGuideError::NoUsableMasts);
}
Ok(masts)
}
fn solved_depths(solved: &[SolvedTier]) -> Result<Vec<f64>, BuildGuideError> {
if solved
.iter()
.any(|tier| matches!(tier.strategy, SolveStrategy::Failed))
{
Err(BuildGuideError::DoesNotSolve(
"the solver could not place every tier.".to_owned(),
))
} else {
Ok(solved.iter().map(|tier| tier.mast).collect())
}
}
fn flat_order(target: &Design) -> Vec<usize> {
target
.cutting_order()
.into_iter()
.filter_map(|tier| match tier {
TierRef::Flat(index) => Some(index),
TierRef::Concave(_) => None,
})
.collect()
}
struct TierFacts {
blocks: Vec<Block>,
names: Vec<String>,
roles: Vec<Role>,
masts: Vec<f64>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum ExactReason {
Anchor,
NoMeetInfo,
MeetsLater,
Missed(f64),
Everything,
TooLarge,
}
#[derive(Clone, Debug, PartialEq)]
enum Meets {
Exact(ExactReason),
Named(Vec<String>),
Unspecified,
}
impl Meets {
const fn kind(&self) -> MeetKind {
match self {
Self::Exact(_) => MeetKind::ExactScale,
Self::Named(_) => MeetKind::Named,
Self::Unspecified => MeetKind::Unspecified,
}
}
const fn is_exact(&self) -> bool {
matches!(self, Self::Exact(_))
}
}
struct PlannedTier {
code: String,
block: Block,
role: Role,
angle_deg: f64,
indices: Vec<f64>,
indices_text: IndicesText,
mast: f64,
meets: Meets,
recipe: TierRecipe,
}
impl PlannedTier {
fn pin(&mut self, reason: ExactReason) {
self.meets = Meets::Exact(reason);
self.recipe.constraint_kind = 2;
self.recipe.constraint_text = mast_text(self.mast);
}
}
fn recipe_for(
name: &str,
angle_deg: f64,
indices: &IndicesText,
meets: &Meets,
mast: f64,
) -> TierRecipe {
let (constraint_kind, constraint_text) = match meets {
Meets::Unspecified => (0, String::new()),
Meets::Named(names) => (1, names.join(", ")),
Meets::Exact(_) => (2, mast_text(mast)),
};
TierRecipe {
name: name.to_owned(),
angle: angle_text(angle_deg),
indices: indices.typed.clone(),
constraint_kind,
constraint_text,
}
}
fn plan_tiers(target: &Design, facts: &TierFacts, order: &[usize]) -> Vec<PlannedTier> {
let gear = target.meta.gear_teeth_abs();
let mut position = vec![0_usize; target.tiers.len()];
for (at, &original) in order.iter().enumerate() {
position[original] = at;
}
let large = target.tiers.len() > MAX_MEET_TIERS;
let codes = target.tier_codes().flat;
let mut anchored: Vec<Block> = Vec::new();
let mut plan = Vec::with_capacity(order.len());
for &original in order {
let tier = &target.tiers[original];
let block = facts.blocks[original];
let anchor = !anchored.contains(&block);
if anchor {
anchored.push(block);
}
let meets = if anchor {
Meets::Exact(ExactReason::Anchor)
} else if large {
Meets::Exact(ExactReason::TooLarge)
} else {
intended_meets(target, original, facts, &position)
};
let typed = indices_text(&tier.indices, gear, tier.angle_deg);
let mast = facts.masts[original];
let recipe = recipe_for(&facts.names[original], tier.angle_deg, &typed, &meets, mast);
plan.push(PlannedTier {
code: codes
.get(original)
.map(|label| label.code.clone())
.unwrap_or_default(),
block,
role: facts.roles[original],
angle_deg: tier.angle_deg,
indices: tier.indices.clone(),
indices_text: typed,
mast,
meets,
recipe,
});
}
plan
}
fn intended_meets(
target: &Design,
original: usize,
facts: &TierFacts,
position: &[usize],
) -> Meets {
let tier = &target.tiers[original];
let stated = match &tier.constraint {
MeetConstraint::ScaleReference(_) => match &tier.imported_meet {
Some(imported @ (MeetConstraint::MeetExisting | MeetConstraint::MeetNamed(_))) => {
imported
}
_ => return Meets::Exact(ExactReason::NoMeetInfo),
},
constraint => constraint,
};
match stated {
MeetConstraint::MeetExisting => Meets::Unspecified,
MeetConstraint::MeetNamed(list) => {
resolve_named(list, original, &target.tiers, &facts.names, position)
.map_or_else(Meets::Exact, Meets::Named)
}
MeetConstraint::ScaleReference(_) => Meets::Exact(ExactReason::NoMeetInfo),
}
}
fn resolve_named(
list: &[String],
this: usize,
tiers: &[ConstraintTier],
names: &[String],
position: &[usize],
) -> Result<Vec<String>, ExactReason> {
let mut resolved: Vec<String> = Vec::new();
for wanted in list {
let wanted = wanted.trim();
let found = tiers
.iter()
.position(|tier| tier.names().contains(&wanted))
.or_else(|| {
tiers
.iter()
.position(|tier| tier.names().iter().any(|n| n.eq_ignore_ascii_case(wanted)))
})
.filter(|&found| found != this)
.ok_or(ExactReason::NoMeetInfo)?;
if position[found] > position[this] {
return Err(ExactReason::MeetsLater);
}
if !resolved.contains(&names[found]) {
resolved.push(names[found].clone());
}
}
if resolved.is_empty() {
Err(ExactReason::NoMeetInfo)
} else {
Ok(resolved)
}
}
fn rebuild(target: &Design, plan: &[PlannedTier]) -> Result<Design, BuildGuideError> {
let gear = target.meta.gear_teeth_abs();
let mut tiers = Vec::with_capacity(plan.len());
let mut names: Vec<String> = Vec::with_capacity(plan.len());
for planned in plan {
let tier =
parse_tier_form(planned.recipe.fields(gear, names.clone())).map_err(|error| {
BuildGuideError::CannotTeach(format!("{}: {error}", planned.recipe.name))
})?;
names.push(planned.recipe.name.clone());
tiers.push(tier);
}
Ok(Design::new(target.preform, target.meta.clone(), tiers))
}
fn deviations(solved: &[SolvedTier], plan: &[PlannedTier]) -> Vec<(usize, f64)> {
solved
.iter()
.zip(plan)
.enumerate()
.filter(|(_, (solved, planned))| {
matches!(solved.strategy, SolveStrategy::Failed)
|| !mast_within(solved.mast, planned.mast, VERIFY_MAST_REL_TOL)
})
.map(|(at, (solved, planned))| {
let relative = (solved.mast - planned.mast).abs() / planned.mast.abs().max(MAST_FLOOR);
(at, relative * 100.0)
})
.collect()
}
fn verify_meets(target: &Design, plan: &mut [PlannedTier]) -> Result<(), BuildGuideError> {
for round in 0..MAX_VERIFY_ROUNDS {
if plan.iter().all(|planned| planned.meets.is_exact()) {
return Ok(());
}
let Ok(solved) = rebuild(target, plan)?.solve() else {
break;
};
if solved.len() != plan.len() {
break;
}
let off = deviations(&solved, plan);
if off.is_empty() {
return Ok(());
}
if round + 1 == MAX_VERIFY_ROUNDS {
break;
}
for (at, percent) in off {
if !plan[at].meets.is_exact() {
plan[at].pin(ExactReason::Missed(percent));
}
}
}
for planned in plan.iter_mut().filter(|planned| !planned.meets.is_exact()) {
planned.pin(ExactReason::Everything);
}
Ok(())
}
fn reference_copy(target: &Design, facts: &TierFacts) -> Design {
let mut copy = target.clone();
for ((tier, name), &mast) in copy.tiers.iter_mut().zip(&facts.names).zip(&facts.masts) {
tier.name.clone_from(name);
tier.constraint = MeetConstraint::ScaleReference(mast);
tier.imported_meet = None;
tier.original_notes = None;
}
copy.tier_targets.clear();
copy.tier_relations.clear();
copy
}