//public BuildItemUnitView Upgraded(IGDetailPlanetService planetService, int userId, int planetId,bool premiumIsActive)
public ItemProgress Upgraded(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, IServiceProvider resolver)
{
var bu = new BuildUpgrade();
bu.SetData(planet.BuildSpaceShipyard, NativeName);
return(base.Upgraded(connection, planet, bu, resolver));
}
private static bool _needUpdate(GDetailPlanetDataModel planet)
{
if (!planet.Resources.AllFull())
{
return(true);
}
if (planet.UnitProgress != null && planet.UnitProgress.Any())
{
return(true);
}
if (planet.BuildSpaceShipyard.IsProgress != null && planet.BuildSpaceShipyard.IsProgress == true)
{
return(true);
}
if (planet.BuildExtractionModule.IsProgress != null && planet.BuildExtractionModule.IsProgress == true)
{
return(true);
}
if (planet.BuildEnergyConverter.IsProgress != null && planet.BuildEnergyConverter.IsProgress == true)
{
return(true);
}
if (planet.BuildStorage.IsProgress != null && planet.BuildStorage.IsProgress == true)
{
return(true);
}
if (planet.Turels.IsProgress != null && planet.Turels.IsProgress == true)
{
return(true);
}
return(false);
}
public int UpgradeForCc(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, BuildUpgrade preResult, IServiceProvider resolver)
{
var bu = new BuildUpgrade();
bu.SetData(planet.BuildEnergyConverter, NativeName);
return(base.UpgradeForCc(connection, planet, userId, premiumIsActive, preResult, CalcCcCurrentPrice(preResult.Progress?.Level ?? 1), resolver));
}
public AdminSpaceModel(GDetailPlanetDataModel planet, MapTypes mapType)
{
Id = planet.Id;
NativeName = planet.Name;
Translate = planet.Description;
MapType = mapType;
}
public GDetailPlanetDataModel AddOrUpdate(IDbConnection connection, GDetailPlanetDataModel dataModel)
{
var db = _planetDetailRepo.AddOrUpdateeModel(connection, dataModel);
var planet = _planetDetailCache.UpdateLocalItem(connection, db);
_planetNameSercheCache.AddOrUpdate(connection, planet.Name, planet.Id, _planetDetailCache);
return(planet);
}
public override List <BuildItemUnitView> GetPlanetBuildList(GDetailPlanetDataModel planet,
UserPremiumWorkModel userPremium)
{
return(new List <BuildItemUnitView>
{
_turels.GetViewModel(planet.Turels, userPremium.IsActive)
});
}
protected ItemProgress Upgraded(IDbConnection connection, GDetailPlanetDataModel planet, BuildUpgrade bu, IServiceProvider resolver)
{
if (!bu.IsUpgradeComplite(bu.Progress))
{
return(bu.Progress);
}
bu.Progress = ItemProgress.ProgressUpdateComplite(bu.Progress);
BuildUpgrade.TransactionBuildUpdate(connection, planet, bu, resolver);
return(bu.Progress);
}
// protected int UpgradeForCc(IGDetailPlanetService planetService,IBalanceCcService balanceService,
//int userId, bool premiumIsActive, BuildUpgrade preResult, int planetId, int calculatedCcPrice)
protected int UpgradeForCc(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, BuildUpgrade preResult, int calculatedCcPrice, IServiceProvider resolver)
{
var storeService = resolver.GetService <IStoreService>();
var preResultCc = storeService.BalanceCalcResultCc(connection, userId, calculatedCcPrice);
preResult.Cc = preResultCc.Quantity;
preResult.Progress = ItemProgress.ProgressUpdateComplite(preResult.Progress);
BuildUpgrade.TransactionBuildUpdate(connection, planet, preResult, resolver, preResultCc);
return(preResult.Cc);
}
public override List <BuildItemUnitView> GetPlanetBuildList(GDetailPlanetDataModel planet,
UserPremiumWorkModel userPremium)
{
return(new List <BuildItemUnitView>
{
_storage.GetViewModel(planet.BuildStorage, userPremium.IsActive, planet.Resources),
_extractionModule.GetViewModel(planet.BuildExtractionModule, userPremium.IsActive,
StorageResources.StorageProportion(planet.ExtractionProportin)),
_energyConverter.GetViewModel(planet.BuildEnergyConverter, userPremium.IsActive)
});
}
public GDetailPlanetDataModel SetInitialHangarAndResource(IDbConnection connection,
GDetailPlanetDataModel planet, bool premium = false)
{
planet.Hangar = UnitList.InitUnitsInOwn(true);
planet.Resources = new StorageResources
{
Current = MaterialResource.InitStartResourses(),
Max = Storage.MaxStorable(1, premium)
};
return(planet);
}
public override List <BuildItemUnitView> GetPlanetBuildList(GDetailPlanetDataModel planet,
UserPremiumWorkModel userPremium)
{
var shipyardColletion = new List <BuildItemUnitView>
{
_spaceShipyard.GetViewModel(planet.BuildSpaceShipyard, userPremium.IsActive)
};
var builds = Unit.GetBuildItemUnitViewList(planet.Hangar, planet.UnitProgress, planet.BuildSpaceShipyard, userPremium, OwnType.Planet);
shipyardColletion.AddRange(builds);
return(shipyardColletion);
}
//BuildItemUnitView
public ItemProgress Upgraded(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, IServiceProvider resolver)
{
var bu = new BuildUpgrade();
bu.SetData(planet.Turels, NativeName);
if (!bu.IsUpgradeComplite(bu.Progress))
{
return(bu.Progress);
}
//planetService.SavePlanet();
bu.Progress = ItemProgress.ProgressUpdateComplite(bu.Progress);
BuildUpgrade.TransactionBuildUpdate(connection, planet, bu, resolver);
return(bu.Progress);
}
public GDetailPlanetDataModel SetInitialPlanetBuilds(GDetailPlanetDataModel planet, int userId = 1)
{
var intiData = ItemProgress.InitBuildingProgress();
var turel = ItemProgress.InitBuildingProgress();
turel.Level = 0;
planet.BuildEnergyConverter = intiData;
planet.BuildExtractionModule = intiData;
planet.BuildStorage = intiData;
planet.BuildSpaceShipyard = intiData;
planet.Turels = turel;
planet.ExtractionProportin = MaterialResource.InitBaseOwnProportion();
planet.UserId = userId;
return(planet);
}
public int UpgradeForCc(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, BuildUpgrade preResult, IServiceProvider resolver)
{
var storeService = resolver.GetService <IStoreService>();
var balanceCc =
storeService.BalanceCalcResultCc(connection, userId, CalcCcCurrentPrice(preResult.Progress?.Level ?? 1));
preResult.Cc = balanceCc.Quantity;
preResult.Progress = ItemProgress.ProgressUpdateComplite(preResult.Progress);
if (preResult.StorageResources == null)
{
throw new Exception(Error.UserResourceNotSetInInstance);
}
preResult.StorageResources.Max = MaxStorable(preResult.Progress?.Level ?? 1, premiumIsActive);
BuildUpgrade.TransactionBuildUpdate(connection, planet, preResult, resolver, balanceCc);
return(preResult.Cc);
}
public static void TransactionBuildUpdate(IDbConnection connection, GDetailPlanetDataModel p, BuildUpgrade buildUpgrade, IServiceProvider resolver, UserBalanceCcDataModel ccDataModel = null)
{
var planetService = resolver.GetService <IGDetailPlanetService>();
if (p == null)
{
throw new Exception(Error.NoData);
}
if (ccDataModel != null)
{
var storeService = resolver.GetService <IStoreService>();
ccDataModel.Quantity = buildUpgrade.Cc;
storeService.AddOrUpdateBalance(connection, ccDataModel);
}
if (buildUpgrade.StorageResources != null)
{
p.Resources = buildUpgrade.StorageResources;
}
BuildNativeNames buildType;
Enum.TryParse(buildUpgrade.NativeName, out buildType);
if (buildType == BuildNativeNames.Storage)
{
p.BuildStorage = buildUpgrade.Progress;
}
else if (buildType == BuildNativeNames.Turel)
{
p.Turels = buildUpgrade.Progress;
}
else if (buildType == BuildNativeNames.SpaceShipyard)
{
p.BuildSpaceShipyard = buildUpgrade.Progress;
}
else if (buildType == BuildNativeNames.EnergyConverter)
{
p.BuildEnergyConverter = buildUpgrade.Progress;
}
else if (buildType == BuildNativeNames.ExtractionModule)
{
p.BuildExtractionModule = buildUpgrade.Progress;
}
planetService.AddOrUpdate(connection, p);
}
public ItemProgress Upgraded(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, IServiceProvider resolver)
{
var progress = planet.BuildStorage;
var preResult = new BuildUpgrade(planet.Resources, progress, NativeName);
//todo не правильно высчитывается время на азуре из за чего вылетает ошибка при ответе от сервера
if (!preResult.IsUpgradeComplite(preResult.Progress))
{
return(preResult.Progress);
}
preResult.Progress = ItemProgress.ProgressUpdateComplite(preResult.Progress);
preResult.StorageResources.Max = MaxStorable(preResult.Progress.Level ?? 1, premiumIsActive);
BuildUpgrade.TransactionBuildUpdate(connection, planet, preResult, resolver);
return(preResult.Progress);
}
private void _createTaskToUser(IDbConnection connection, GDetailPlanetDataModel targetPlanet)
{
var taskModel = _createTaskModelToUser(connection, targetPlanet);
_activatedPlanetIds.Add(taskModel.TargetPlanetId);
var targetUserId = targetPlanet.UserId;
var timer = _taskRunner.OnUserTaskCreated(taskModel, taskModel.SourceUserId);
if (!timer.Started)
{
var logger = _svp.GetService <IDemonAzureLogItem>();
logger.CrateAndSave("UserTaskDataModel", "NpcTaskRunner._createTaskToUser", taskModel, taskModel.Id);
timer.Dispose();
return;
}
_taskService.NotyfyTaskCreated(taskModel, targetUserId);
}
private static Dictionary <UnitType, HangarUnitsOut> GetherPlanetUnits(GDetailPlanetDataModel planet,
UserPremiumWorkModel userPremium)
{
var shipyardlevel = 1;
var shipyard = planet.BuildSpaceShipyard;
if (shipyard?.Level != null)
{
shipyardlevel = (int)shipyard.Level;
}
var outUnits = UnitList.ConvertToHangar(planet.Hangar);
if (planet.UnitProgress == null || !planet.UnitProgress.Any())
{
return(outUnits);
}
SetUnitUpgradeInHangarUnit(userPremium, shipyardlevel, ref outUnits, planet.UnitProgress);
return(outUnits);
}
/// <summary>
/// Не делает проверки планеты на текущее состояние.
/// Если планета уже имеет установленного владельца, проверку нужно делать перед методом
/// В любом слае отправляет запрос на обновление планеты, и извлечение альянса
/// </summary>
/// <param name="connection"></param>
/// <param name="planet"></param>
/// <param name="newOwner"></param>
/// <param name="allianceService"></param>
public void UpdatePlanetOwner(IDbConnection connection, GDetailPlanetDataModel planet, int newOwner, IAllianceService allianceService)
{
var npc = NpcHelper.GetNpcByName(Npc.SkagyName);
if (newOwner == npc.NpcUser.Id)
{
planet.AllianceId = npc.NpcAlliance.Id;
planet.UserId = newOwner;
AddOrUpdate(connection, planet);
return;
}
var allianceUser = allianceService.GetAllianceUserByUserId(connection, newOwner);
if (planet.AllianceId != allianceUser.AllianceId)
{
planet.AllianceId = allianceUser.AllianceId;
}
planet.UserId = newOwner;
AddOrUpdate(connection, planet);
}
private void _calcDangerLevel(int timeBeforeAtk, int currentTime, GDetailPlanetDataModel planet)
{
var deltaTime = currentTime - timeBeforeAtk;
if (deltaTime <= UnixTime.OneHourInSecond)
{
planet.DangerLevel += 2;
}
if (deltaTime <= UnixTime.OneDayInSecond)
{
planet.DangerLevel += 1;
}
else if (deltaTime >= UnixTime.OneDayInSecond * 7 && planet.DangerLevel - 1 > 1)
{
planet.DangerLevel -= 1;
}
else if (deltaTime >= UnixTime.OneDayInSecond * 30)
{
planet.DangerLevel = 1;
}
}
private UserTaskDataModel _createTaskModelToUser(IDbConnection connection, GDetailPlanetDataModel targetPlanet)
{
//return new UserTaskDataModel();
//tmp
var targeFleet = _createSkagryFleet(targetPlanet.Hangar, 0.3);
var targetPlanetGeometry = _geometryPlanetService.GetGeometryPlanetById(connection, targetPlanet.Id);
var targetPlanetSystem =
_systemService.GetDetailSystemBySystemId(connection, targetPlanetGeometry.SystemId);
var minTime = SKAGRY_FLY_TYME_SECOND;
var maxTime = minTime * 2;
var duration = _rand.Next(minTime, maxTime);
var newTaskItem = new UserTaskDataModel
{
SourceTypeId = 20,
SourceOwnType = false,
SourceOwnName = Npc.SkagyName,
SourceUserId = Npc.SkagryGameUserId,
SourceOwnId = 0,
TargetPlanetName = targetPlanet.Name,
DateActivate = UnixTime.UtcNow(),
Duration = duration,
SourceFleet = targeFleet, // targeFleet, // targetPlanet.Hangar.CloneDeep(),
IsAtack = true,
IsTransfer = false,
TargetPlanetId = targetPlanet.Id,
TargetPlanetTypeId = targetPlanetGeometry.TypeId,
TargetSystemName = targetPlanetSystem.Name,
SourceSystemName = "Unknown",
Canselation = false,
TaskEnd = false
};
// todo save to db new Task Item
var dataTask = _taskService.AddOrUpdate(connection, newTaskItem);
return(dataTask);
}
public GDetailPlanetDataModel ResetProgress(ref GDetailPlanetDataModel planet)
{
var storage = planet.BuildStorage;
var buildEnergyConverter = planet.BuildEnergyConverter;
var buildExtractionModule = planet.BuildExtractionModule;
var buildSpaceShipyard = planet.BuildSpaceShipyard;
var turels = planet.Turels;
turels.Level = 0;
ItemProgress.ResetProgress(ref storage);
ItemProgress.ResetProgress(ref buildEnergyConverter);
ItemProgress.ResetProgress(ref buildEnergyConverter);
ItemProgress.ResetProgress(ref buildExtractionModule);
ItemProgress.ResetProgress(ref buildSpaceShipyard);
ItemProgress.ResetProgress(ref turels);
planet.BuildStorage = storage;
planet.BuildEnergyConverter = buildEnergyConverter;
planet.BuildExtractionModule = buildExtractionModule;
planet.BuildSpaceShipyard = buildSpaceShipyard;
planet.Turels = turels;
return(planet);
}
public GDetailPlanetDataModel UserPlanet(IDbConnection connection, GDetailPlanetDataModel planet, UserPremiumWorkModel userPremium, IGDetailPlanetService planetService)
{
return(_planetRunner.RunSinglePlanet(connection, planet, userPremium, planetService));
}
public PlanshetViewData GetPlanetCollection(IDbConnection connection, UserDataModel user, UserPremiumWorkModel userPremium, GDetailPlanetDataModel own, bool synchronize = true)
{
var planet = own;
if (synchronize)
{
planet = _synchronizer.UserPlanet(connection, own, userPremium, _gDetailPlanetService);
}
var planetPlanshet = _getPlanetCollection(GetPlanetBuildList(planet, userPremium));
planetPlanshet.IsMother = false;
return(planetPlanshet);
}
private void _updatePlanet(IDbConnection connection, GDetailPlanetDataModel planet,
Func <GDetailPlanetDataModel, GDetailPlanetDataModel> action)
{
_gDetailPlanetService.AddOrUpdate(connection, action(planet));
}
public bool CallculateNewResources(IDbConnection connection, IGDetailPlanetService service, GDetailPlanetDataModel planet, EnergyConverterChangeOut clientData)
{
var dbRes = planet.Resources;
var level = planet.BuildEnergyConverter.GetLevel(1);
var calculatedRes = _callculateNewResources(dbRes, clientData, level);
if (dbRes.Equals(calculatedRes))
{
return(false);
}
planet.Resources = calculatedRes;
service.AddOrUpdate(connection, planet);
return(true);
}
public ItemProgress Upgraded(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, IServiceProvider resolver)
{
var bu = new BuildUpgrade(planet.Resources, planet.BuildEnergyConverter, NativeName);
return(base.Upgraded(connection, planet, bu, resolver));
}
public abstract List <BuildItemUnitView> GetPlanetBuildList(GDetailPlanetDataModel planet,
UserPremiumWorkModel userPremium);
public ItemProgress FixPlanetItemProgress(UnitType unitType, GDetailPlanetDataModel planet,
UserPremiumWorkModel userPremium)
{
return(FixItemProgress(unitType, planet.Hangar, planet.UnitProgress, userPremium,
planet.BuildSpaceShipyard));
}
public int UpgradeForCc(IDbConnection connection, GDetailPlanetDataModel planet, int userId, bool premiumIsActive, BuildUpgrade preResult, IServiceProvider resolver)
{
return(base.UpgradeForCc(connection, planet, userId, premiumIsActive, preResult,
CalcCcCurrentPrice(preResult.Progress?.Level ?? 1), resolver));
}