protected override bool CheckAllocatedCapability(Capability capability)
{
if (!Robot.CanSwitch())
return false;
var processCapability = capability as ProcessCapability;
return processCapability == null || Robot.CanApply(processCapability);
}
public override bool IsEquivalentTo(Capability capability)
{
var produce = capability as ProduceCapability;
if (produce == null)
return false;
return Tasks.SequenceEqual(produce.Tasks);
}
public override void OnReconfigured()
{
_currentCapability = null;
base.OnReconfigured();
// For now, the resource disappears magically...
Robot.DiscardWorkpiece();
}
public override bool IsEquivalentTo(Capability capability)
{
var process = capability as ProcessCapability;
return ProductionAction == process?.ProductionAction;
}
public RobotAgent(Capability[] capabilities, Robot robot)
: base(capabilities)
{
Robot = robot;
}
public override void Process(ProcessCapability capability)
{
if (Resource == null)
return;
if (_currentCapability != capability)
{
// Switch the capability; if we fail to do so, remove all other capabilities from the available ones and
// trigger a reconfiguration
if (Robot.SwitchCapability(capability))
_currentCapability = capability;
else
{
AvailableCapabilities.RemoveAll(c => c != _currentCapability);
CheckConstraints();
return;
}
}
// Apply the capability; if we fail to do so, remove it from the available ones and trigger a reconfiguration
if (!Robot.ApplyCapability())
{
AvailableCapabilities.Remove(capability);
CheckConstraints();
}
else
{
if (Resource.State.Count() == Resource.Task.Capabilities.Length)
throw new InvalidOperationException();
Resource.OnCapabilityApplied();
}
}
protected virtual bool CheckAllocatedCapability(Capability capability)
{
return true;
}
public override bool IsEquivalentTo(Capability capability)
{
return capability is ConsumeCapability;
}
private bool ContainsCapability(IEnumerable<Capability> capabilities, Capability capability)
{
return capabilities.Any(c => c.IsEquivalentTo(capability));
}
