// public void AddChangeListener(Action<int> action)
// {
// _onChange += action;
// }
// public void RemoveChangeListener(Action<int> action)
// {
// _onChange -= action;
// }
public void AnalyzeTaskProcessingData(TaskProcessData data)
{
List <float> ratios = new List <float>();
foreach (var item in data.resources.MainCards)
{
int sum = CardsUtils.GetCardsSumByParam(item.Value, data.department.Designation.value);
int need = data.task.Task.GetNeed(item.Key);
float ratio = (float)sum / need;
ratios.Add(Mathf.Abs(ratio - 1));
}
float diff = (ratios.Sum() - ratios.Count * _signChangingDiff) * -_changingRate;
// int staffSum = CardsSystem.GetCardsValuesByParam(data.staff, data.department.Designation.value).Sum();
// int eqSum = CardsSystem.GetCardsValuesByParam(data.equipment, data.department.Designation.value).Sum();
// int staffNeed = data.task.TaskController.GetStaffNeed();
// int eqNeed = data.task.TaskController.GetEquipmentNeed();
// float staffRatio = (float)staffSum/staffNeed;
// float eqRatio = (float)eqSum/eqNeed;
// float diff = (Mathf.Abs(staffRatio - 1) + Mathf.Abs(eqRatio - 1) - 2 * _signChangingDiff) * -_changingRate;
float tempValue = currentValue + diff;
currentValue = Mathf.Clamp((int)Mathf.Round(tempValue), _minValue, maxValue);
RaiseChangeEvent(currentValue);
}
// public void AddChangeListener(Action<int> action)
// {
// _onChange += action;
// }
// public void RemoveChangeListener(Action<int> action)
// {
// _onChange -= action;
// }
public void AnalyzeTaskProcessingData(TaskProcessData pd)
{
int depNum = pd.department.Designation.value;
List <float> coeffs = pd.task.Task.GetDepartmentsCoefficients();
// List<float> coeffs = pd.task.TaskController.GetDepartmentsCoefficients();
if (coeffs.Count < depNum)
{
return;
}
float depCoeff = coeffs[depNum - 1];
float coeffsSum = 0f;
for (int i = 0; i < coeffs.Count; i++)
{
if (i != depNum - 1)
{
coeffsSum += coeffs[i];
}
}
float averageCoeff = coeffsSum / (coeffs.Count - 1);
float tempValue = currentValue + (depCoeff - averageCoeff) * _changingRate;
currentValue = Mathf.Clamp((int)Mathf.Round(tempValue), _minValue, maxValue);
RaiseChangeEvent(currentValue);
}
public void RecordTaskProcessData(TaskProcessData pd, Dictionary <CardType, int> resources)
{
_taskProcessingCount++;
_monthTaskProcessingCount++;
window.AddTaskProcessingRecord(
pd.task.Task.Data.Name, pd.resultingTime, pd.resultingReward, resources);
UpdateTaskCounts();
}
// public void AddChangeListener(Action<int> action)
// {
// _onChange += action;
// }
// public void RemoveChangeListener(Action<int> action)
// {
// _onChange -= action;
// }
public void AnalyzeTaskProcessingData(TaskProcessData data)
{
float ratio = data.task.Task.Data.BaseTime / data.resultingTime;
// float tempValue = currentValue + (ratio - _signChangingRatio) * _changingRate;
float tempValue = currentValue + (ratio - data.department.CurrentTimeRateNorm) * _changingRate; // can't predict behaviour
currentValue = Mathf.Clamp((int)Math.Round(tempValue), _minValue, maxValue);
RaiseChangeEvent(currentValue);
}
private void CalculateIndicators(TaskProcessData pd) ///
{
pi.AnalyzeTaskProcessingData(pd);
Debug.Log(pi.CurrentValue);
ri.AnalyzeTaskProcessingData(pd);
Debug.Log(ri.CurrentValue);
rai.AnalyzeTaskProcessingData(pd);
Debug.Log(rai.CurrentValue);
}
private void FinishTaskPreparation(TaskProcessData processData)
{
if (_hasActiveTask)
{
return;
}
ESKnowledgeBase.QuestionPicker.PickNext(processData.task.Task);
_currentProcessData = processData;
_hasActiveTask = true;
}
private void OccupyResources(TaskProcessData pd)
{
pd.department.Controller.OccupyAmountedResources();
foreach (List <ICard> cards in pd.resources.MainCards.Values)
{
foreach (ICard card in cards)
{
pd.department.Controller.OccupyResource(card);
}
}
}
private void StartTaskProcessing(IChoice choice)
{
CalculatePerfomance(_currentProcessData);
EvaluateAnsweringPerformance(choice);
decisionsRulesManager.ProcessChoiceForDepartment(
choice, _currentProcessData.department.Designation);
OccupyResources(_currentProcessData);
taskProcessStarted.RaiseEvent();
StartTaskExecuting(_currentProcessData);
_currentProcessData.department.ProcessTaskExecutingData(_currentProcessData);
_currentProcessData = null;
_hasActiveTask = false;
}
public void ProcessTaskRecord(TaskProcessData pd)
{
_processTasksRecords.Add(pd);
currentPeriodData.UpdateTasksTime(pd.resultingTime, pd.baseTime);
foreach (var item in pd.resources.MainCards)
{
int sum = CardsUtils.GetCardsSumByParam(item.Value, DepartmentParameter) * pd.resultingTime;
if (item.Value.Count > 0)
{
currentPeriodData.UpdateResourcesWorkingSum(item.Key, sum,
pd.task.Task.GetNeed(item.Key) * pd.resultingTime);
}
}
}
public void ProcessTaskExecutingData(TaskProcessData pd)
{
Init();
controller.ProcessTaskRecord(pd);
_indicators.ProcessData(pd);
var resources = new Dictionary <CardType, int>();
foreach (var item in pd.resources.MainCards)
{
resources[item.Key] = CardsUtils.GetCardsSumByParam(item.Value, designation.value);
}
_display.RecordTaskProcessData(pd, resources);
}
public void AddTaskProcessData(TaskProcessData pd) ///
{
_tasksData.Add(pd);
_periodInfo.UpdateTasksTime(pd.resultingTime, pd.task.Task.Data.BaseTime);
foreach (var item in pd.resources.MainCards)
{
int sum = CardsUtils.GetCardsSumByParam(item.Value, Designation.value) * pd.resultingTime;
if (item.Value.Count > 0)
{
_periodInfo.UpdateResourcesWorkingSum(item.Key, sum,
pd.task.Task.GetNeed(item.Key) * pd.resultingTime);
}
}
CalculateIndicators(pd);
}
private void StartTaskExecuting(TaskProcessData pd)
{
pd.task.AddExecutedListener(() =>
{
addPointsChannel.RaiseEvent((int)Math.Ceiling((double)pd.resultingReward));
foreach (List <ICard> cards in pd.resources.MainCards.Values)
{
foreach (ICard card in cards)
{
pd.department.Controller.ReleaseResource(card);
}
}
TaskStatesChanger.StartTaskRestoration(pd.task, pd.baseTime);
});
TaskStatesChanger.StartTaskExecuting(pd.task, (int)Math.Ceiling((double)pd.resultingTime));
}
private void CalculatePerfomance(TaskProcessData pd)
{
Dictionary <CardType, List <int> > resourcesValues = new Dictionary <CardType, List <int> >();
foreach (var item in pd.resources.MainCards)
{
resourcesValues[item.Key] = CardsUtils.GetCardsValuesByParam(item.Value,
pd.department.Designation.value);
}
float basePenalty = CalculateTaskPenalty(pd.task.Task, resourcesValues);
pd.department.MakeNewConsumablesToExpend();
float consumablesPenaltyRate = pd.department.GetConsumablesPenaltyRate();
float depCoeff = GetTaskDepartmentCoeff(pd.task.Task, pd.department.Designation);
pd.resultingTime += CalculateResultingTime(basePenalty, consumablesPenaltyRate, depCoeff, pd.baseTime);
pd.resultingReward += CalculateResultingReward(basePenalty, consumablesPenaltyRate,
depCoeff, pd.task.Task.Data.BaseReward);
}
public void ActivateTaskProcessing(ITaskCard cardData, Department dep)
{
_processData = new TaskProcessData();
_processData.task = cardData;
_processData.department = dep;
_departmentParameter = dep.Designation;
window.Reset();
window.OnCardSelection += UpdateSelectedSum;
window.SetProcessData(dep.DepBaseData.fullName, dep.Designation.value,
cardData.Task.Data.Name, cardData.Task.Data.Description,
cardData.Task.GetNeed());
Dictionary <CardType, List <ICard> > winRes = new Dictionary <CardType, List <ICard> >();
foreach (CardType type in window.GetResourcesTypes())
{
winRes[type] = dep.GetAvailableResourcesCardsByType(type);
}
window.SetResources(winRes);
window.Active = true;
ToShowWindow.RaiseEvent(window);
}
public void ProcessData(TaskProcessData pd)
{
Performance.AnalyzeTaskProcessingData(pd);
Relevance.AnalyzeTaskProcessingData(pd);
Rationality.AnalyzeTaskProcessingData(pd);
}
