public static TurnedUnit CalculateTrickyUnitTimeProduction(TimeLineStatus premiumTimeLine,
TurnedUnit turnedUnit,
int currTime, int shipyardLevel)
{
var lastUpgrade = turnedUnit.DateLastUpgrade;
var index = premiumTimeLine.Points.FindLastIndex(j => j <= lastUpgrade);
var baseUnitProductionTime = UnitHelper.GetBaseUnit(turnedUnit.UnitType).BasePrice.TimeProduction;
// 0-1 true
// 1-2 false
// 2-3 true
for (var i = index; i < premiumTimeLine.Points.Count(); i++)
{
var statusPremiumIsActive = false;
if (i != -1)
{
statusPremiumIsActive = premiumTimeLine.Status[i];
}
var oneUnitProductionSpeedPerSecond = CalculateTimeProduction(baseUnitProductionTime,
statusPremiumIsActive, shipyardLevel);
int duration;
var hasNextPoint = (premiumTimeLine.Points.Count() - 1 > i);
if (hasNextPoint)
{
var nextPoint = premiumTimeLine.Points[i + 1];
duration = nextPoint - lastUpgrade;
lastUpgrade = nextPoint;
}
else
{
duration = currTime - lastUpgrade;
lastUpgrade = currTime;
}
if (duration > (turnedUnit.TotalCount - turnedUnit.ReadyUnits) * oneUnitProductionSpeedPerSecond)
{
turnedUnit.ReadyUnits += (currTime - turnedUnit.DateLastUpgrade) / oneUnitProductionSpeedPerSecond;
if (turnedUnit.ReadyUnits >= turnedUnit.TotalCount)
{
turnedUnit.ReadyUnits = turnedUnit.TotalCount;
}
lastUpgrade = currTime;
break;
}
turnedUnit.ReadyUnits += duration / oneUnitProductionSpeedPerSecond;
}
turnedUnit.DateLastUpgrade = lastUpgrade;
return(turnedUnit);
}
private Dictionary <string, TurnedUnit> SetUnitProgress()
{
var time = UnixTime.UtcNow();
var delay = 11000;
var units = new Dictionary <string, TurnedUnit>();
var turFrig = new TurnedUnit
{
DateLastUpgrade = time - delay,
DateCreate = time - delay,
ReadyUnits = 0,
TotalCount = 100,
UnitName = Frigate.NativeName
};
units.Add(Frigate.NativeName, turFrig);
return(units);
}
private static int CalcUnitDurationRemainTime(TurnedUnit tu, int baseTimeProduction, int buildLevel,
UserPremiumWorkModel userPremium, double?remainToComplete = null)
{
double rem;
var modifedTime = CalculateTimeProduction(baseTimeProduction, userPremium.IsActive, buildLevel);
if (remainToComplete == null)
{
rem = tu.TotalCount - tu.ReadyUnits;
}
else
{
rem = (double)remainToComplete;
}
if (!userPremium.IsActive)
{
if (buildLevel == 1)
{
return((int)Math.Ceiling(baseTimeProduction * rem));
}
return((int)Math.Ceiling(modifedTime * rem));
}
var premiumRemainDuration = userPremium.EndTime - tu.DateLastUpgrade;
var premiumUnitCount = premiumRemainDuration / modifedTime;
if (premiumUnitCount >= rem)
{
return((int)Math.Ceiling(modifedTime * rem));
}
var deltaUnit = rem - premiumUnitCount;
return((int)Math.Ceiling((modifedTime * premiumUnitCount) + (deltaUnit * baseTimeProduction)));
}
private static ItemProgress CalculateUnitProgress(TurnedUnit turnedUnit, int baseTimeProduction, int builLevel,
UserPremiumWorkModel userPremium, int hangarCount)
{
var remainToComplete = turnedUnit.TotalCount - turnedUnit.ReadyUnits;
int?duration = null;
if (remainToComplete > 0)
{
duration = CalcUnitDurationRemainTime(turnedUnit, baseTimeProduction, builLevel, userPremium,
remainToComplete);
}
return(new ItemProgress
{
Advanced = turnedUnit,
StartTime = UnixTime.UtcNow(),
Duration = duration,
IsProgress = (duration != null),
Level = hangarCount,
RemainToComplete = remainToComplete
});
}
/// <summary>
/// Вычисляет данные для записи нового эллемента очереди юнита на мезере ил планете
/// </summary>
/// <param name="unitType">Native name Unit</param>
/// <param name="count">Желаемое количество для покупки</param>
/// <param name="resource">текушие ресурсы пользователя</param>
/// <param name="unit">тип юнита который мы покупаем</param>
/// <param name="resultPrice">Итоговая стоимость пачки с учетом проверки на нехватку ресурсов</param>
/// <param name="unitTurnModel">новый эллемент очереди (еще не просумированный с основной очередью)</param>
private static void InitializeUnitTurn(UnitType unitType, int count, StorageResources resource, UnitModel unit, out MaterialResource resultPrice, out TurnedUnit unitTurnModel)
{
var basePrice = unit.BasePrice;
//вычисляем стоимость пачки
var price = MaterialResource.CalcUnitsPrice(basePrice, count);
int resultCount;
//проверяем хватает ли ресурсов
if (MaterialResource.EnoughResourses(resource.Current, price))
{
resultCount = count;
resultPrice = price;
}
else
{
var newCount = CalculateMaxCount(basePrice, resource.Current);
if (newCount == 0)
{
throw new Exception(Error.NotEnoughResources);
}
resultCount = newCount;
resultPrice = MaterialResource.CalcUnitsPrice(basePrice, newCount);
}
//устанавливаем модель
var time = UnixTime.UtcNow();
unitTurnModel = new TurnedUnit
{
TotalCount = resultCount,
DateCreate = time,
UnitType = unitType,
DateLastUpgrade = time
};
}
private static void FixProgreses(UserMothershipDataModel mother, UserPremiumWorkModel userPremium)
{
#region Premium
var pt = userPremium.TimeLineStatus;
#endregion
#region CalcResource
var lastUpgradeProductionTime = mother.LastUpgradeProductionTime;
var beforeResource = mother.Resources.CloneDeep();
var last = pt?.Status?.Last();
var curPrem = (last != null && (bool)last);
// var motherExtatracionLevel = 1;
var motherExtatracionLevel = 22;
StorageResources.CalculateProductionResources(beforeResource,
mother.ExtractionProportin, ref lastUpgradeProductionTime, motherExtatracionLevel,
curPrem,
ExtractionModule.BaseProportion.Ir,
ExtractionModule.BaseProportion.Dm,
ExtractionModule.GetPower,
(res) => { StorageResourcesService.FixCurrentResources(res); }
);
if (!mother.Resources.Equals(beforeResource))
{
mother.Resources = beforeResource;
}
#region Laboratory
if (mother.TechProgress.Select(i => i.Value).ToList().Any(i => i.IsProgress == true))
{
var techService = new BattleTeches(mother.TechProgress);
if (techService.CalculateTechProgreses(techService.GetTeches(false), userPremium))
{
mother.TechProgress = techService.ConvertToDbTeches();
}
}
#endregion
mother.LastUpgradeProductionTime = lastUpgradeProductionTime;
#endregion
if (mother.UnitProgress == null || !mother.UnitProgress.Any())
{
if (mother.UnitProgress == null)
{
mother.UnitProgress = new Dictionary <UnitType, TurnedUnit>();
}
return;
}
#region Calc UnitProgress
const int shipyardLevel = 1;
var pureTurn = mother.UnitProgress;
var hangarUnits = mother.Hangar;
bool unitInProgress;
TurnedUnit.CalculateUserUnits(pt, ref pureTurn, out unitInProgress, ref hangarUnits, shipyardLevel,
Unit.CalculateTrickyUnitTimeProduction,
(unitType) => UnitHelper.GetBaseUnit(unitType).BasePrice.TimeProduction, Unit.CalculateTimeProduction);
mother.UnitProgress = unitInProgress ? pureTurn : new Dictionary <UnitType, TurnedUnit>();
mother.Hangar = hangarUnits;
#endregion
}
private static void AddUnitToCurrenUnitTurn(ref Dictionary <UnitType, TurnedUnit> collection, TurnedUnit newItem)
{
if (collection.ContainsKey(newItem.UnitType))
{
collection[newItem.UnitType].TotalCount += newItem.TotalCount;
}
else
{
collection.Add(newItem.UnitType, newItem);
}
}
private static void FixProgreses(GDetailPlanetDataModel planet, UserPremiumWorkModel userPremium)
{
#region Calc BuildProgress
var pt = userPremium.TimeLineStatus;
if (planet.BuildEnergyConverter.CheckProgressIsDone())
{
ItemProgress.ProgressUpdateComplite(planet.BuildEnergyConverter);
}
if (planet.BuildExtractionModule.CheckProgressIsDone())
{
ItemProgress.ProgressUpdateComplite(planet.BuildExtractionModule);
}
if (planet.BuildSpaceShipyard.CheckProgressIsDone())
{
ItemProgress.ProgressUpdateComplite(planet.BuildSpaceShipyard);
}
if (planet.BuildStorage.CheckProgressIsDone())
{
ItemProgress.ProgressUpdateComplite(planet.BuildStorage);
}
if (planet.Turels.CheckProgressIsDone())
{
ItemProgress.ProgressUpdateComplite(planet.Turels);
}
var extractionLevel = 1;
if (planet.BuildExtractionModule?.Level != null)
{
extractionLevel = (int)planet.BuildExtractionModule.Level;
}
#endregion
#region CalcResource
var lastUpgradeProductionTime = planet.LastUpgradeProductionTime;
var beforeResource = planet.Resources.CloneDeep();
var last = pt?.Status?.Last();
var curPrem = (last != null && (bool)last);
StorageResources.CalculateProductionResources(beforeResource,
planet.ExtractionProportin, ref lastUpgradeProductionTime, extractionLevel,
curPrem,
ExtractionModule.BaseProportion.Ir,
ExtractionModule.BaseProportion.Dm,
ExtractionModule.GetPower, (res) => { StorageResourcesService.FixCurrentResources(res); });
if (!planet.Resources.Equals(beforeResource))
{
planet.Resources = beforeResource;
}
planet.LastUpgradeProductionTime = lastUpgradeProductionTime;
#endregion
if (planet.UnitProgress == null || !planet.UnitProgress.Any())
{
return;
}
#region Calc UnitProgress
var shipyardLevel = planet.BuildSpaceShipyard.Level ?? 1;
var pureTurn = planet.UnitProgress;
var hangarUnits = planet.Hangar;
bool unitInProgress;
TurnedUnit.CalculateUserUnits(pt, ref pureTurn, out unitInProgress, ref hangarUnits, shipyardLevel,
Unit.CalculateTrickyUnitTimeProduction,
(unitType) => UnitHelper.GetBaseUnit(unitType).BasePrice.TimeProduction, Unit.CalculateTimeProduction);
planet.UnitProgress = unitInProgress ? pureTurn : new Dictionary <UnitType, TurnedUnit>();
planet.Hangar = hangarUnits;
#endregion
}
private static BuildItemUnitView GetUnitViewInSpaceShipyard(UnitType unitType, int hangarCount,
TurnedUnit upgrade, ItemProgress spaceShipyard, UserPremiumWorkModel userPremium)
{
var unit = UnitHelper.GetBaseUnit(unitType);
var baseTime = unit.BasePrice.TimeProduction;
var buildLevel = 1;
if (spaceShipyard?.Level != null)
{
buildLevel = (int)spaceShipyard.Level;
}
var price = unit.BasePrice.CreateNewFromThis();
//=================
price.TimeProduction =
(int)Math.Ceiling(CalculateTimeProduction(baseTime, userPremium.IsActive, buildLevel));
var progress = ((upgrade != null)
? CalculateUnitProgress(upgrade, baseTime, buildLevel, userPremium, hangarCount)
: new ItemProgress
{
Level = hangarCount,
IsProgress = false
});
var unitText = unit.Text;
var model = new BuildItemUnitView
{
Progress = progress,
TranslateName = unitText.Name,
NativeName = unit.Key,
IconSelf = unit.SpriteImages.Icon,
Info = new BuildDropItemInfo
{
Description = unitText.Description,
DropImage = unit.SpriteImages.Detail,
Data = new BuildItemUnitData(true, unit.UnitStats)
},
//Action = new BuildDropItemAction
//{
// ViewPath = BuildExtractionModuleActions.ViewPath,
// Data = new BuildExtractionModuleActions
// {
// //todo реализовать
// Power = power,
// Percent = new MaterialResource().Init(percentE, percentIr, percentDm),
// ExtractionPerHour = new MaterialResource().Init(valE, valIr, valDm),
// }
//},
Update = new BuildDropItemUpdate
{
Price = price,
IsUnitUpgrade = true
},
IsBuildItem = false
};
model.SetComplexButtonView();
model.Update.SetButtons();
return(model);
}
