611 lines
27 KiB
C#
611 lines
27 KiB
C#
using Simulator.Data;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UVC.UI.Window.PropertyWindow;
|
|
using System;
|
|
|
|
public class RobotArmProperty : MonoBehaviour
|
|
{
|
|
[SerializeField]
|
|
private PropertyWindow propertyWindow;
|
|
|
|
private void Awake()
|
|
{
|
|
propertyWindow.PropertyValueChanged += OnPropertyValueChanged;
|
|
}
|
|
|
|
public void SetProertyWindow(ComponentType type,ComponentDataBase data)
|
|
{
|
|
Debug.Log(data);
|
|
InitRobotArmProperty(data as RobotArmDataClass);
|
|
}
|
|
|
|
void SaveChange(object source, object value, string name)
|
|
{
|
|
var path = PathIndexer.GetNodePath(source);
|
|
Patch updateData = new Patch();
|
|
updateData.value = value;
|
|
UpdateValueStack.AddPatch($"{path}.{name}", value);
|
|
}
|
|
|
|
public void InitRobotArmProperty(RobotArmDataClass robotArm)
|
|
{
|
|
List<IPropertyEntry> entries = new List<IPropertyEntry>
|
|
{
|
|
new StringProperty("name", "이름", robotArm.name)
|
|
{
|
|
IsReadOnly=true
|
|
},
|
|
new StringProperty("label", "라벨", robotArm.label)
|
|
{
|
|
IsReadOnly=false
|
|
}.Bind(
|
|
setter: v => {robotArm.label = v;SaveChange(robotArm,v,"label"); }
|
|
),
|
|
new Vector2Property("Position","X,Y 좌표(m)", new Vector2(robotArm.physical.position.x,robotArm.physical.position.z))
|
|
{
|
|
IsReadOnly=false
|
|
}.Bind(
|
|
setter: v => {robotArm.physical.position.x = v.x;robotArm.physical.position.z = v.y; SaveChange(robotArm,v,"physical.position"); }
|
|
),
|
|
|
|
new EnumProperty("display_mode_RobotArmSpeedPolicy", "로봇팔 속도 정책",robotArm.robot_arm_speed_policy.policy).Bind(
|
|
setter: v=>{robotArm.robot_arm_speed_policy=PolicyFactory.Create(v.ToString());SaveChange(robotArm,v.ToString(),"robot_arm_speed_policy.type");}
|
|
),
|
|
CreateRobotArmSpeedPolicy_Constant(robotArm),
|
|
CreateRobotArmSpeedPolicy_Normal(robotArm),
|
|
CreateRobotArmSpeedPolicy_Uniform(robotArm),
|
|
CreateRobotArmSpeedPolicy_Exponential(robotArm),
|
|
CreateRobotArmSpeedPolicy_Triangular(robotArm),
|
|
|
|
new EnumProperty("display_mode_FailureRatePolicy", "고장률 정책",robotArm.failure_rate_policy.policy).Bind(
|
|
setter: v=>{robotArm.failure_rate_policy=PolicyFactory.Create(v.ToString());SaveChange(robotArm,v.ToString(),"failure_rate_policy.type");}
|
|
),
|
|
CreateFailureRatePolicy_Constant(robotArm),
|
|
CreateFailureRatePolicy_Normal(robotArm),
|
|
CreateFailureRatePolicy_Uniform(robotArm),
|
|
CreateFailureRatePolicy_Exponential(robotArm),
|
|
CreateFailureRatePolicy_Triangular(robotArm),
|
|
|
|
new EnumProperty("display_mode_RepairTimePolicy", "수리 시간 정책",robotArm.failure_rate_policy.policy).Bind(
|
|
setter: v=>{robotArm.failure_rate_policy=PolicyFactory.Create(v.ToString());SaveChange(robotArm,v.ToString(),"failure_rate_policy.type");}
|
|
),
|
|
CreateRepairTimePolicy_Constant(robotArm),
|
|
CreateRepairTimePolicy_Normal(robotArm),
|
|
CreateRepairTimePolicy_Uniform(robotArm),
|
|
CreateRepairTimePolicy_Exponential(robotArm),
|
|
CreateRepairTimePolicy_Triangular(robotArm),
|
|
|
|
CreateInputsGroup(robotArm),
|
|
CreateOutputsGroup(robotArm),
|
|
|
|
CreateRequireResourceGroup(robotArm)
|
|
};
|
|
|
|
propertyWindow.LoadMixedProperties(entries);
|
|
|
|
HandleDisplayModeChanged_RobotArmSpeedPolicy(robotArm.robot_arm_speed_policy.policy.ToString());
|
|
HandleDisplayModeChanged_FailureRatePolicy(robotArm.failure_rate_policy.policy.ToString());
|
|
HandleDisplayModeChanged_RepairTimePolicy(robotArm.repair_time_policy.policy.ToString());
|
|
|
|
CreateCostGroup(robotArm);
|
|
}
|
|
|
|
private void OnPropertyValueChanged(object sender, PropertyValueChangedEventArgs e)
|
|
{
|
|
Debug.Log($"[PropertyChanged] Id:{e.PropertyId}, Type:{e.PropertyType}, Value:{e.NewValue}");
|
|
|
|
// 동적 그룹 표시/비표시 테스트
|
|
if (e.PropertyId == "display_mode_RobotArmSpeedPolicy")
|
|
{
|
|
string selectedMode = e.NewValue.ToString();
|
|
HandleDisplayModeChanged_RobotArmSpeedPolicy(selectedMode);
|
|
}
|
|
if (e.PropertyId == "display_mode_FailureRatePolicy")
|
|
{
|
|
string selectedMode = e.NewValue.ToString();
|
|
HandleDisplayModeChanged_FailureRatePolicy(selectedMode);
|
|
}
|
|
if (e.PropertyId == "display_mode_RepairTimePolicy")
|
|
{
|
|
string selectedMode = e.NewValue.ToString();
|
|
HandleDisplayModeChanged_RepairTimePolicy(selectedMode);
|
|
}
|
|
}
|
|
|
|
#region 로봇팔 속도 정책
|
|
private PropertyGroup CreateRobotArmSpeedPolicy_Constant(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RobotArmSpeedPolicy_Constant", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RobotArmSpeedPolicy_Constant_Value", "상수 값", (robotArm.robot_arm_speed_policy as Policy_Constant) ?.value ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Constant).value = v;SaveChange(robotArm,v,"robot_arm_speed_policy.value"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRobotArmSpeedPolicy_Normal(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RobotArmSpeedPolicy_Normal", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RobotArmSpeedPolicy_Normal_Mean", "정규 분포 표준치", (robotArm.robot_arm_speed_policy as Policy_Normal) ?.mean ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Normal).mean = v;SaveChange(robotArm,v,"robot_arm_speed_policy.mean"); }
|
|
),
|
|
new FloatProperty("RobotArmSpeedPolicy_Normal_Gap", "정규 분포 표준 편차", (robotArm.robot_arm_speed_policy as Policy_Normal) ?.stddev ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Normal).stddev = v;SaveChange(robotArm,v,"robot_arm_speed_policy.stddev"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRobotArmSpeedPolicy_Uniform(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RobotArmSpeedPolicy_Uniform", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RobotArmSpeedPolicy_Uniform_Min", "균등 분포 최소값", (robotArm.robot_arm_speed_policy as Policy_Uniform) ?.min_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Uniform).min_val = v;SaveChange(robotArm,v,"robot_arm_speed_policy.min_val"); }
|
|
),
|
|
new FloatProperty("RobotArmSpeedPolicy_Uniform_Max", "균등 분포 최대값", (robotArm.robot_arm_speed_policy as Policy_Uniform) ?.max_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Uniform).max_val = v;SaveChange(robotArm,v,"robot_arm_speed_policy.max_val"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRobotArmSpeedPolicy_Exponential(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RobotArmSpeedPolicy_Exponential", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RobotArmSpeedPolicy_Exponential_Mean", "지수 분포 평균치", (robotArm.robot_arm_speed_policy as Policy_Exponential) ?.mean ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Exponential).mean = v;SaveChange(robotArm,v,"robot_arm_speed_policy.mean"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRobotArmSpeedPolicy_Triangular(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RobotArmSpeedPolicy_Triangular", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RobotArmSpeedPolicy_Triangular_Min", "지수 분포 최소값", (robotArm.robot_arm_speed_policy as Policy_Triangular) ?.min_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Triangular).min_val = v;SaveChange(robotArm,v,"robot_arm_speed_policy.min_val"); }
|
|
),
|
|
new FloatProperty("RobotArmSpeedPolicy_Triangular_Mean", "지수 분포 최빈값", (robotArm.robot_arm_speed_policy as Policy_Triangular) ?.mode ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Triangular).mode = v;SaveChange(robotArm,v,"robot_arm_speed_policy.mode"); }
|
|
),
|
|
new FloatProperty("RobotArmSpeedPolicy_Triangular_Max", "지수 분포 최대값", (robotArm.robot_arm_speed_policy as Policy_Triangular) ?.max_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.robot_arm_speed_policy as Policy_Triangular).max_val = v;SaveChange(robotArm,v,"robot_arm_speed_policy.max_val"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private void HandleDisplayModeChanged_RobotArmSpeedPolicy(string mode)
|
|
{
|
|
// 모든 조건부 그룹 숨김
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Constant", false);
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Normal", false);
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Uniform", false);
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Exponential", false);
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Triangular", false);
|
|
|
|
// 선택된 모드에 따라 해당 그룹만 표시
|
|
switch (mode)
|
|
{
|
|
case "Constant":
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Constant", true);
|
|
break;
|
|
case "Normal":
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Normal", true);
|
|
break;
|
|
case "Uniform":
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Uniform", true);
|
|
break;
|
|
case "Exponential":
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Exponential", true);
|
|
break;
|
|
case "Triangular":
|
|
propertyWindow.SetGroupVisibility("RobotArmSpeedPolicy_Triangular", true);
|
|
break;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region 고장률 정책
|
|
private PropertyGroup CreateFailureRatePolicy_Constant(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("FailureRatePolicy_Constant", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("FailureRatePolicy_Constant_Value", "상수 값", (robotArm.failure_rate_policy as Policy_Constant) ?.value ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Constant).value = v;SaveChange(robotArm,v,"failure_rate_policy.value"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateFailureRatePolicy_Normal(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("FailureRatePolicy_Normal", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("FailureRatePolicy_Normal_Mean", "정규 분포 표준치", (robotArm.failure_rate_policy as Policy_Normal) ?.mean ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Normal).mean = v;SaveChange(robotArm,v,"repair_time_policy.mean"); }
|
|
),
|
|
new FloatProperty("FailureRatePolicy_Normal_Gap", "정규 분포 표준 편차", (robotArm.failure_rate_policy as Policy_Normal) ?.stddev ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Normal).stddev = v;SaveChange(robotArm,v,"repair_time_policy.stddev"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateFailureRatePolicy_Uniform(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("FailureRatePolicy_Uniform", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("FailureRatePolicy_Uniform_Min", "균등 분포 최소값", (robotArm.failure_rate_policy as Policy_Uniform) ?.min_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Uniform).min_val = v;SaveChange(robotArm,v,"failure_rate_policy.min_val"); }
|
|
),
|
|
new FloatProperty("FailureRatePolicy_Uniform_Max", "균등 분포 최대값", (robotArm.failure_rate_policy as Policy_Uniform) ?.max_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Uniform).max_val = v;SaveChange(robotArm,v,"failure_rate_policy.max_val"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateFailureRatePolicy_Exponential(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("FailureRatePolicy_Exponential", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("FailureRatePolicy_Exponential_Mean", "지수 분포 평균치", (robotArm.failure_rate_policy as Policy_Exponential) ?.mean ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Exponential).mean = v;SaveChange(robotArm,v,"failure_rate_policy.mean"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateFailureRatePolicy_Triangular(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("FailureRatePolicy_Triangular", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("FailureRatePolicy_Triangular_Min", "지수 분포 최소값", (robotArm.failure_rate_policy as Policy_Triangular) ?.min_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Triangular).min_val = v;SaveChange(robotArm,v,"failure_rate_policy.min_val"); }
|
|
),
|
|
new FloatProperty("FailureRatePolicy_Triangular_Mean", "지수 분포 최빈값", (robotArm.failure_rate_policy as Policy_Triangular) ?.mode ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Triangular).mode = v;SaveChange(robotArm,v,"failure_rate_policy.mode"); }
|
|
),
|
|
new FloatProperty("FailureRatePolicy_Triangular_Max", "지수 분포 최대값", (robotArm.failure_rate_policy as Policy_Triangular) ?.max_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Triangular).max_val = v;SaveChange(robotArm,v,"failure_rate_policy.max_val"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private void HandleDisplayModeChanged_FailureRatePolicy(string mode)
|
|
{
|
|
// 모든 조건부 그룹 숨김
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Constant", false);
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Normal", false);
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Uniform", false);
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Exponential", false);
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Triangular", false);
|
|
|
|
// 선택된 모드에 따라 해당 그룹만 표시
|
|
switch (mode)
|
|
{
|
|
case "Constant":
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Constant", true);
|
|
break;
|
|
case "Normal":
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Normal", true);
|
|
break;
|
|
case "Uniform":
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Uniform", true);
|
|
break;
|
|
case "Exponential":
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Exponential", true);
|
|
break;
|
|
case "Triangular":
|
|
propertyWindow.SetGroupVisibility("FailureRatePolicy_Triangular", true);
|
|
break;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region 수리 시간 정책
|
|
private PropertyGroup CreateRepairTimePolicy_Constant(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RepairTimePolicy_Constant", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RepairTimePolicy_Constant_Value", "상수 값", (robotArm.repair_time_policy as Policy_Constant) ?.value ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Constant).value = v;SaveChange(robotArm,v,"repair_time_policy.value"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRepairTimePolicy_Normal(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RepairTimePolicy_Normal", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RepairTimePolicy_Normal_Mean", "정규 분포 표준치", (robotArm.repair_time_policy as Policy_Normal) ?.mean ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Normal).mean = v;SaveChange(robotArm,v,"failure_rate_policy.mean"); }
|
|
),
|
|
new FloatProperty("RepairTimePolicy_Normal_Gap", "정규 분포 표준 편차", (robotArm.repair_time_policy as Policy_Normal) ?.stddev ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.failure_rate_policy as Policy_Normal).stddev = v;SaveChange(robotArm,v,"failure_rate_policy.stddev"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRepairTimePolicy_Uniform(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RepairTimePolicy_Uniform", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RepairTimePolicy_Uniform_Min", "균등 분포 최소값", (robotArm.repair_time_policy as Policy_Uniform) ?.min_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Uniform).min_val = v;SaveChange(robotArm,v,"repair_time_policy.min_val"); }
|
|
),
|
|
new FloatProperty("RepairTimePolicy_Uniform_Max", "균등 분포 최대값", (robotArm.repair_time_policy as Policy_Uniform) ?.max_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Uniform).max_val = v;SaveChange(robotArm,v,"repair_time_policy.max_val"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRepairTimePolicy_Exponential(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RepairTimePolicy_Exponential", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RepairTimePolicy_Exponential_Mean", "지수 분포 평균치", (robotArm.repair_time_policy as Policy_Exponential) ?.mean ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Exponential).mean = v;SaveChange(robotArm,v,"repair_time_policy.mean"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRepairTimePolicy_Triangular(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RepairTimePolicy_Triangular", "", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new FloatProperty("RepairTimePolicy_Triangular_Min", "지수 분포 최소값", (robotArm.repair_time_policy as Policy_Triangular) ?.min_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Triangular).min_val = v;SaveChange(robotArm,v,"repair_time_policy.min_val"); }
|
|
),
|
|
new FloatProperty("RepairTimePolicy_Triangular_Mean", "지수 분포 최빈값", (robotArm.repair_time_policy as Policy_Triangular) ?.mode ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Triangular).mode = v;SaveChange(robotArm,v,"repair_time_policy.mode"); }
|
|
),
|
|
new FloatProperty("RepairTimePolicy_Triangular_Max", "지수 분포 최대값", (robotArm.repair_time_policy as Policy_Triangular) ?.max_val ?? 0f)
|
|
{
|
|
}.Bind(
|
|
setter: v => {(robotArm.repair_time_policy as Policy_Triangular).max_val = v;SaveChange(robotArm,v,"repair_time_policy.max_val"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
|
|
private void HandleDisplayModeChanged_RepairTimePolicy(string mode)
|
|
{
|
|
// 모든 조건부 그룹 숨김
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Constant", false);
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Normal", false);
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Uniform", false);
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Exponential", false);
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Triangular", false);
|
|
|
|
// 선택된 모드에 따라 해당 그룹만 표시
|
|
switch (mode)
|
|
{
|
|
case "Constant":
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Constant", true);
|
|
break;
|
|
case "Normal":
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Normal", true);
|
|
break;
|
|
case "Uniform":
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Uniform", true);
|
|
break;
|
|
case "Exponential":
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Exponential", true);
|
|
break;
|
|
case "Triangular":
|
|
propertyWindow.SetGroupVisibility("RepairTimePolicy_Triangular", true);
|
|
break;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
PropertyGroup CreateInputsGroup(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("InputConnect", "입력 연결", isExpanded: true);
|
|
foreach(var input in robotArm.inputs)
|
|
{
|
|
var property = new IntProperty($"{input.target}prefab", input.target, input.required_items);
|
|
group.AddItem(property);
|
|
}
|
|
return group;
|
|
}
|
|
|
|
PropertyGroup CreateOutputsGroup(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("OutputConnect", "출력 연결", isExpanded: true);
|
|
foreach (var output in robotArm.outputs)
|
|
{
|
|
var property = new IntProperty($"{output.target}prefab", output.target, output.required_items);
|
|
group.AddItem(property);
|
|
}
|
|
return group;
|
|
}
|
|
|
|
private PropertyGroup CreateRequireResourceGroup(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("RequireResource", "자원 할당", isExpanded: true);
|
|
|
|
// 1) required_resources 인덱스화
|
|
var requiredIndex = BuildRequiredIndex(robotArm);
|
|
|
|
int count = 0;
|
|
foreach (var resource in ComponentsManager.logicDetailData.infrastructure.resources)
|
|
{
|
|
if (!string.Equals(resource.type, "worker"))
|
|
continue;
|
|
|
|
// 2) 매칭 키 결정: 여기서는 resource.name을 키로 쓴다고 가정
|
|
var key = resource.name; // ★ label 말고 name/id 권장
|
|
bool isRequired = key != null && requiredIndex.ContainsKey(key);
|
|
|
|
// 3) 초기값을 isRequired로
|
|
var property = new BoolProperty($"required_resource[{count++}]", resource.label, isRequired);
|
|
|
|
// 4) (선택) 변경 시 processor.required_resources 업데이트 + Patch 저장까지 Bind로 연결
|
|
property.Bind(setter: v =>
|
|
{
|
|
SetRequiredResource(robotArm, key, v);
|
|
// SaveChange(processor or sourceRoot, processorRequiredPath...) 형태로 패치 기록
|
|
});
|
|
|
|
group.AddItem(property);
|
|
}
|
|
|
|
return group;
|
|
}
|
|
|
|
private void SetRequiredResource(RobotArmDataClass robotArm, string resourceName, bool required)
|
|
{
|
|
if (string.IsNullOrEmpty(resourceName)) return;
|
|
|
|
robotArm.required_resources ??= new List<Required_Resources>();
|
|
|
|
int idx = robotArm.required_resources.FindIndex(x => x != null && x.name == resourceName);
|
|
|
|
if (required)
|
|
{
|
|
if (idx < 0)
|
|
{
|
|
robotArm.required_resources.Add(new Required_Resources
|
|
{
|
|
name = resourceName,
|
|
count = 1,
|
|
selection_policy = "random" // 기본값 정책은 규칙에 맞춰 결정
|
|
});
|
|
}
|
|
else
|
|
{
|
|
// 이미 있으면 유지 (필요 시 count/policy 기본 보정)
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (idx >= 0)
|
|
robotArm.required_resources.RemoveAt(idx);
|
|
}
|
|
}
|
|
|
|
private Dictionary<string, Required_Resources> BuildRequiredIndex(RobotArmDataClass robotArm)
|
|
{
|
|
var dict = new Dictionary<string, Required_Resources>(StringComparer.Ordinal);
|
|
|
|
if (robotArm.required_resources == null) return dict;
|
|
|
|
foreach (var rr in robotArm.required_resources)
|
|
{
|
|
if (rr?.name == null) continue;
|
|
dict[rr.name] = rr;
|
|
}
|
|
return dict;
|
|
}
|
|
|
|
PropertyGroup CreateCostGroup(RobotArmDataClass robotArm)
|
|
{
|
|
var group = new PropertyGroup("CostSetting", "비용 설정", isExpanded: true);
|
|
group.AddItems(new IPropertyItem[]
|
|
{
|
|
new IntProperty("Operating_Cost_Per_Hour", "시간당 가동 비용", robotArm.operating_cost_per_hour)
|
|
{
|
|
}.Bind(
|
|
setter: v => {robotArm.operating_cost_per_hour = v;SaveChange(robotArm,v,"operating_cost_per_hour"); }
|
|
),
|
|
new IntProperty("Idle_Cost_Per_Hour", "시간당 대기 비용", robotArm.idle_cost_per_hour)
|
|
{
|
|
}.Bind(
|
|
setter: v => {robotArm.idle_cost_per_hour = v;SaveChange(robotArm,v,"idle_cost_per_hour"); }
|
|
),
|
|
new IntProperty("Failure_Cost", "고장 1회 손실 비용", robotArm.failure_cost)
|
|
{
|
|
}.Bind(
|
|
setter: v => {robotArm.failure_cost = v;SaveChange(robotArm,v,"failure_cost"); }
|
|
),
|
|
new IntProperty("repair_cost_per_hour", "시간당 수리 비용", robotArm.repair_cost_per_hour)
|
|
{
|
|
}.Bind(
|
|
setter: v => {robotArm.repair_cost_per_hour = v;SaveChange(robotArm,v,"repair_cost_per_hour"); }
|
|
),
|
|
});
|
|
return group;
|
|
}
|
|
}
|