public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
DifficultyManager d = Singleton<DifficultyManager>.instance;
int multiplier;
if (service == Service.Road)
{
multiplier = d.MaintenanceCostMultiplier_Road.Value;
}
else if (service == Service.PublicTransport)
{
multiplier = d.MaintenanceCostMultiplier_Public.Value;
}
else if (service == Service.Education || service == Service.Electricity || service == Service.FireDepartment ||
service == Service.Garbage || service == Service.HealthCare || service == Service.PoliceDepartment || service == Service.Water)
{
multiplier = d.MaintenanceCostMultiplier_Service.Value;
}
else
{
multiplier = d.MaintenanceCostMultiplier.Value;
}
return (int)(0.01f * originalMaintenanceCost * multiplier + 0.99f);
}
public async Task <ActionResult <SubService> > Create(SubService value)
{
//SubService obj = new SubService(value);
value.Service = await _service.GetById(value.ServiceId.ToString());
_SubService.Add(value);
Random generator = new Random();
String password = generator.Next(0, 999999).ToString("D6");
Login login = new Login();
login.Email = "*****@*****.**";
login.Role = "Admin";
login.RandomPass = password;
loginInterface.Add(login);
// it will be null
//var testSubService = await _SubService.GetById(value.);
// If everything is ok then:
await _uow.Commit();
// The product will be added only after commit
// testProduct = await _productRepository.GetById(product.Id);
return(RedirectToAction("Index"));
}
public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
switch (service)
{
case Service.Education:
return (int)Math.Round(originalMaintenanceCost * vars.datam.education, 0);
case Service.Electricity:
return (int)Math.Round(originalMaintenanceCost * vars.datam.electricity, 0);
case Service.FireDepartment:
return (int)Math.Round(originalMaintenanceCost * vars.datam.fire, 0);
case Service.Garbage:
return (int)Math.Round(originalMaintenanceCost * vars.datam.garbage, 0);
case Service.HealthCare:
return (int)Math.Round(originalMaintenanceCost * vars.datam.health, 0);
case Service.PublicTransport:
return (int)Math.Round(originalMaintenanceCost * vars.datam.transport, 0);
case Service.PoliceDepartment:
return (int)Math.Round(originalMaintenanceCost * vars.datam.police, 0);
case Service.Road:
return (int) Math.Round(originalMaintenanceCost*vars.datam.road, 0);
case Service.Water:
return (int) Math.Round(originalMaintenanceCost*vars.datam.water, 0);
case Service.Beautification:
return (int) Math.Round(originalMaintenanceCost*vars.datam.beauty, 0);
case Service.Monument:
return (int) Math.Round(originalMaintenanceCost*vars.datam.monument, 0);
default:
return originalMaintenanceCost;
}
}
public async Task <ActionResult> DeleteConfirmed(int id, int companyservicesID)
{
SubService subService = await db.SubServices.FindAsync(id);
subService.ServiceImage = db.ServiceImages.Where(c => c.SubService.SubServiceId == id).ToList();
//if we have images for subservice we need to delete them first
if (subService.ServiceImage != null)
{
foreach (var item in subService.ServiceImage.ToList())
{
//delete image files with thumbnail
PhotoFileManager manager = new PhotoFileManager(PhotoManagerType.Service);
manager.Delete(item.FileName, true);
//delete image from db
db.ServiceImages.Remove(item);
}
}
db.SubServices.Remove(subService);
await db.SaveChangesAsync();
return(RedirectToAction("Index", "SubServices", new { id = companyservicesID }));
}
public override int OnAddResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
if (resource == EconomyResource.TourismIncome)
{
// Changing the "amount" value does change the tourism income value displayed in the Economy panel,
// but does NOT add actual money to the player. Therefore
// the increased cash amount should be added manually, taking into account m_taxMultiplier value.
EconomyManager em = Singleton<EconomyManager>.instance;
// Get taxMultiplier value
FieldInfo field = em.GetType().GetField("m_taxMultiplier", BindingFlags.NonPublic | BindingFlags.Instance);
int m_taxMultiplier = (int)field.GetValue(em);
int newAmount = amount * PTM_Options.Instance.TourismIncomeMultiplier;
em.AddPrivateIncome(
(int)((newAmount - amount) * 10000L / m_taxMultiplier), // Ectract "amount", because it is already added, and exclude the influence of m_taxMultiplier
(ItemClass.Service)service,
(ItemClass.SubService)subService,
(ItemClass.Level)level,
100 // Set 100% tax rate because we want to add actual money as it is.
);
return newAmount;
}
// Bonus feature :)
if ((ItemClass.SubService)subService == ItemClass.SubService.PublicTransportTaxi)
{
return amount * PTM_Options.Instance.TaxiIncomeMultiplier;
}
return amount;
}
public async Task <IActionResult> PutSubService([FromRoute] int id, [FromBody] SubService subservice)
{
var _context = new ServicesDbContext();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != subservice.Id)
{
return(BadRequest());
}
_context.Entry(subservice).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubServiceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Update(SubService document)
{
var def = Builders <SubService> .Update
.Set(it => it.OwnerServiceName, document.OwnerServiceName)
.Set(it => it.SubServiceName, document.SubServiceName);
collection.UpdateOne(it => it.SubServiceId == document.SubServiceId, def);
}
public IActionResult Create()
{
ViewBag.ServiceId = new SelectList(_database.Services, "ServiceId", "Name");
var _subService = new SubService();
return(PartialView("Create", _subService));
}
public async Task <ActionResult <SubService> > Create()
{
SubService value = new SubService();
ViewBag.ServiceId = new SelectList(await _service.GetAll(), "Id", "ServiceName");
return(View());
}
public IActionResult SubServiceInsert(SubService model)
{
if (ModelState.IsValid)
{
model.SubServiceId = Guid.NewGuid().ToString();
collection.Create(model);
}
ModelState.Clear();
return(View());
}
public override OfficeLevelUp OnCalculateOfficeLevelUp(OfficeLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID,
Service service, SubService subService, Level currentLevel)
{
if (HistoricalStatusDataManager.Instance.IsHistorical(buildingID))
{
levelUp.targetLevel = currentLevel;
}
return(levelUp);
}
public override int OnGetRefundAmount(int constructionCost, int refundAmount, Service service, SubService subService, Level level)
{
// TODO: make optional
if (service == Service.Road)
{
return constructionCost;
}
return refundAmount;
}
public override CommercialLevelUp OnCalculateCommercialLevelUp(CommercialLevelUp levelUp, int averageWealth, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
DifficultyManager d = Singleton<DifficultyManager>.instance;
if (levelUp.landValueProgress != 0)
{
Level targetLevel;
int target2 = d.CommercialTargetLandValue.GetValue(Level.Level2);
int target3 = d.CommercialTargetLandValue.GetValue(Level.Level3);
if (landValue < target2)
{
targetLevel = Level.Level1;
levelUp.landValueProgress = 1 + (int)(15f * landValue / target2 + 0.49f);
}
else if (landValue < target3)
{
targetLevel = Level.Level2;
levelUp.landValueProgress = 1 + (int)(15f * (landValue - target2) / (target3 - target2) + 0.49f);
}
else
{
targetLevel = Level.Level5;
levelUp.landValueProgress = 1;
}
if (targetLevel < currentLevel)
{
levelUp.landValueProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.landValueProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
}
levelUp.landValueTooLow = false;
if (currentLevel == Level.Level2)
{
if (landValue < d.CommercialTargetLandValue.GetTooLowValue(Level.Level2)) levelUp.landValueTooLow = true;
}
else if (currentLevel == Level.Level3)
{
if (landValue < d.CommercialTargetLandValue.GetTooLowValue(Level.Level3)) levelUp.landValueTooLow = true;
}
return levelUp;
}
public async Task <ActionResult <SubService> > Edit(string id, SubService value)
{
value.Id = ObjectId.Parse(id);
value.Service = await _service.GetById(value.ServiceId.ToString());
_SubService.Update(value, id);
await _uow.Commit();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit([Bind(Include = "SubServiceId,Title,Description")] SubService subService, string companyservicesID)
{
if (ModelState.IsValid)
{
db.Entry(subService).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index", "SubServices", new { id = companyservicesID }));
}
return(View(subService));
}
public override IndustrialLevelUp OnCalculateIndustrialLevelUp(IndustrialLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
DifficultyManager d = Singleton<DifficultyManager>.instance;
if (levelUp.serviceProgress != 0)
{
Level targetLevel;
int target2 = d.IndustrialTargetScore.GetValue(Level.Level2);
int target3 = d.IndustrialTargetScore.GetValue(Level.Level3);
if (serviceScore < target2)
{
targetLevel = Level.Level1;
levelUp.serviceProgress = 1 + (int)(15f * serviceScore / target2 + 0.49f);
}
else if (serviceScore < target3)
{
targetLevel = Level.Level2;
levelUp.serviceProgress = 1 + (int)(15f * (serviceScore - target2) / (target3 - target2) + 0.49f);
}
else
{
targetLevel = Level.Level5;
levelUp.serviceProgress = 1;
}
if (targetLevel < currentLevel)
{
levelUp.serviceProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.serviceProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
}
levelUp.tooFewServices = false;
if (currentLevel == Level.Level2)
{
if (serviceScore < d.IndustrialTargetScore.GetTooLowValue(Level.Level2)) levelUp.tooFewServices = true;
}
else if (currentLevel == Level.Level3)
{
if (serviceScore < d.IndustrialTargetScore.GetTooLowValue(Level.Level3)) levelUp.tooFewServices = true;
}
return levelUp;
}
public override int OnAddResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
if (resource == EconomyResource.RewardAmount)
{
DifficultyManager d = Singleton<DifficultyManager>.instance;
return (int)(0.01f * amount * d.RewardMultiplier.Value + 0.99f);
}
return amount;
}
public override int OnGetRelocationCost(int constructionCost, int relocationCost, Service service, SubService subService, Level level)
{
try
{
return DataStore.calcObjects[DataStore.RELOC].calculateReturnValue(constructionCost);
}
#pragma warning disable
catch (Exception e)
#pragma warning enable
{
return relocationCost;
}
}
public async Task <ActionResult> Create([Bind(Include = "SubServiceId,Title,Description")] SubService subService, int CompanyServiceId)
{
if (ModelState.IsValid)
{
subService.CompanyService = db.CompanyServices.Find(CompanyServiceId);
db.SubServices.Add(subService);
await db.SaveChangesAsync();
return(RedirectToAction("Index", new { id = CompanyServiceId }));
}
return(View(subService));
}
public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
try
{
return DataStore.calcObjects[DataStore.MAINT].calculateReturnValue(originalMaintenanceCost);
}
#pragma warning disable
catch (Exception e)
#pragma warning enable
{
return originalMaintenanceCost;
}
}
public async Task <IActionResult> PostSubService([FromBody] SubService subservice)
{
var _context = new ServicesDbContext();
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.SubService.Add(subservice);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSubService", new { id = subservice.Id }, subservice));
}
public override int OnGetConstructionCost(int originalConstructionCost, Service service, SubService subService, Level level)
{
try
{
// This value is used as the input for relocation and for refund
return DataStore.calcObjects[DataStore.CONSTRUCT].calculateReturnValue(originalConstructionCost);
}
#pragma warning disable
catch (Exception e)
#pragma warning enable
{
return originalConstructionCost;
}
}
public override CommercialLevelUp OnCalculateCommercialLevelUp(CommercialLevelUp levelUp, int averageWealth, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
if (levelUp.landValueProgress != 0)
{
Level targetLevel;
if (landValue < 30)
{
targetLevel = Level.Level1;
levelUp.landValueProgress = 1 + (landValue * 15 + 15) / 30;
}
else if (landValue < 60)
{
targetLevel = Level.Level2;
levelUp.landValueProgress = 1 + ((landValue - 30) * 15 + 15) / 30;
}
else
{
targetLevel = Level.Level5;
levelUp.landValueProgress = 1;
}
if (targetLevel < currentLevel)
{
levelUp.landValueProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.landValueProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
}
levelUp.landValueTooLow = false;
if (currentLevel == Level.Level2)
{
if (landValue < 15) levelUp.landValueTooLow = true;
}
else if (currentLevel == Level.Level3)
{
if (landValue < 40) levelUp.landValueTooLow = true;
}
return levelUp;
}
public override IndustrialLevelUp OnCalculateIndustrialLevelUp(IndustrialLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
if (levelUp.serviceProgress != 0)
{
Level targetLevel;
if (serviceScore < 40)
{
targetLevel = Level.Level1;
levelUp.serviceProgress = 1 + (serviceScore * 15 + 20) / 40;
}
else if (serviceScore < 80)
{
targetLevel = Level.Level2;
levelUp.serviceProgress = 1 + ((serviceScore - 40) * 15 + 20) / 40;
}
else
{
targetLevel = Level.Level5;
levelUp.serviceProgress = 1;
}
if (targetLevel < currentLevel)
{
levelUp.serviceProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.serviceProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
}
levelUp.tooFewServices = false;
if (currentLevel == Level.Level2)
{
if (serviceScore < 25) levelUp.tooFewServices = true;
}
else if (currentLevel == Level.Level3)
{
if (serviceScore < 60) levelUp.tooFewServices = true;
}
return levelUp;
}
/// <summary>
/// Office level up control - game extension method.
/// Used to override 'too few services' complaint as appropriate.
/// </summary>
/// <param name="levelUp">Original upgrade struct (target level and progress)</param>
/// <param name="averageEducation">Average education for the building (ignored)</param>
/// <param name="serviceScore">Building service score (ignored)</param>
/// <param name="buildingID">Building instance ID</param>
/// <param name="service">Building service (ignored)</param>
/// <param name="subService">Building subservice (ignored)</param>
/// <param name="currentLevel">Existing building level (ignored)</param>
/// <returns>Revised target level (level and progress)</returns>
/// <returns></returns>
public override OfficeLevelUp OnCalculateOfficeLevelUp(OfficeLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID,
Service service, SubService subService, Level currentLevel)
{
// Check if this building is RICO or not.
bool isRICO = IsRICOBuilding(buildingID);
// Check if the relevant 'ignore too few services complaint' setting is set.
if ((ModSettings.noServicesOther && !isRICO) || (ModSettings.noServicesRico && isRICO))
{
// It is - force too few services complaint off.
levelUp.tooFewServices = false;
}
return(levelUp);
}
// GET: SubServices/Edit/5
public async Task <ActionResult> Edit(int?id, int CompanyServiceId)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SubService subService = await db.SubServices.FindAsync(id);
if (subService == null)
{
return(HttpNotFound());
}
ViewBag.CompanyServiceId = CompanyServiceId;
return(View(subService));
}
public override int OnGetConstructionCost(int originalConstructionCost, Service service, SubService subService, Level level)
{
if (SaveData2.saveData.DifficultyLevel < DifficultyLevel.Hard)
{
return originalConstructionCost;
}
var multiplier = 1.4;
if (originalConstructionCost > 30000000)
{
multiplier = 20;
}
else if (subService == SubService.PublicTransportMetro)
{
if (originalConstructionCost > 10000)
{
multiplier = 3;
}
else
{
multiplier = 6;
}
}
else
{
switch (service)
{
case Service.Education:
multiplier = 2;
break;
case Service.Monument:
multiplier = 2;
break;
case Service.Road:
if (originalConstructionCost >= 7000)
{
multiplier = 4;
}
else
{
multiplier = 2.5;
}
break;
}
}
return (int)Math.Min(Math.Round((originalConstructionCost * multiplier), 2), int.MaxValue);
}
public bool Matches(ushort buildingId)
{
Building building = BuildingManager.m_buildings.m_buffer[buildingId];
var info = building.Info;
if (info == null)
{
return(false);
}
if (AiType != null && !AiType.IsInstanceOfType(info.GetAI()))
{
return(false);
}
return(Service.Equals(info.GetService()) &&
(AnySubService || SubService.Equals(info.GetSubService())));
}
public async Task <IActionResult> Create(SubService _subService)
{
if (ModelState.IsValid)
{
_subService.CreatedBy = Convert.ToInt32(_session.GetInt32("MDnAloggedinuserid"));
_subService.DateCreated = DateTime.Now;
_subService.LastModifiedBy = Convert.ToInt32(_session.GetInt32("MDnAloggedinuserid"));
_subService.DateLastModified = DateTime.Now;
TempData["subservice"] = "You have successfully added Meck Doramen And Associates's Subservice !!!";
TempData["notificationType"] = NotificationType.Success.ToString();
await _database.SubServices.AddAsync(_subService);
await _database.SaveChangesAsync();
return(Json(new { success = true }));
}
ViewBag.ServiceId = new SelectList(_database.Services, "ServiceId", "Name", _subService.ServiceId);
return(View(_subService));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
var S1 = new Service("name1", "", "", "", 10, 5);
var S2 = new Service("name1", "", "", "", 10, 4);
var S3 = new Service("name1", "", "", "", 10, 3);
var Su1 = new SubService("subservice", 19920);
var Su2 = new SubService("subservice1", 1920);
var Su4 = new SubService("subservice3", 192);
var Su3 = new SubService("subservice2", 9920);
Su1.AddSubService(Su2);
S1.AddSubService(Su3);
S1.AddSubService(Su1);
S2.AddSubService(Su4);
tree.ItemSource = new Service[5] {
S1,
S2,
S3,
new Service("name1", "", "", "", 10, 2),
new Service("name1", "", "", "", 10, 1)
};
}
public async Task <IActionResult> Edit(int?id, SubService subService)
{
if (id != subService.SubServiceId)
{
return(RedirectToAction("Index", "Error"));
}
if (ModelState.IsValid)
{
try
{
subService.DateLastModified = DateTime.Now;
subService.LastModifiedBy = Convert.ToInt32(_session.GetInt32("MDnAloggedinuserid"));
_database.Update(subService);
await _database.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubServiceExists(subService.SubServiceId))
{
return(RedirectToAction("Index", "Error"));
}
else
{
throw;
}
}
TempData["subservice"] = "You have successfully modified Meck Doramen And Associates's Sub Service !!!";
TempData["notificationType"] = NotificationType.Success.ToString();
return(Json(new { success = true }));
}
ViewBag.ServiceId = new SelectList(_database.Services, "ServiceId", "Name", subService.ServiceId);
return(View(subService));
}
public override int OnAddResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
if (SaveData2.saveData.DifficultyLevel != DifficultyLevel.Vanilla && resource == EconomyResource.PrivateIncome)
{
if (amount > 0)
{
return 0;
}
else
{
return -amount;
}
}
if (SaveData2.saveData.DifficultyLevel < DifficultyLevel.Hard)
{
return amount;
}
if (resource == EconomyResource.RewardAmount)
{
return amount / 4;
}
return amount;
}
// Thread: Simulation
public ResidentialLevelUp OnCalculateResidentialLevelUp(ResidentialLevelUp levelUp, int averageEducation, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
return levelUp;
}
public override ResidentialLevelUp OnCalculateResidentialLevelUp(ResidentialLevelUp levelUp, int averageEducation, int lv, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
if (SaveData2.saveData.DifficultyLevel == DifficultyLevel.Vanilla)
{
return levelUp;
}
var instance = Singleton<BuildingManager>.instance.m_buildings.m_buffer[(int)buildingID];
var zone = instance.Info.m_class.GetZone();
int buildingWealth = instance.m_customBuffer1;
float education = 0;
float happy = 0;
float commute = 0;
var levelUpHelper = LevelUpHelper3.instance;
var serviceScore = levelUpHelper.GetProperServiceScore(buildingID);
levelUpHelper.GetEducationHappyScore(buildingID, out education, out happy, out commute);
Level targetLevel = Level.Level5;
for (var i = 0; i < 5; i += 1)
{
if (serviceScore < levelUpHelper.GetServiceThreshhold((ItemClass.Level)i, zone) || (buildingWealth != 0 && buildingWealth < levelUpHelper.GetWealthThreshhold((ItemClass.Level)i, zone)) || education < levelUpHelper.GetEducationThreshhold((ItemClass.Level)i, zone))
{
targetLevel = (Level)i;
levelUp.landValueProgress = 1 + CalcProgress(serviceScore, levelUpHelper.GetServiceThreshhold((ItemClass.Level)i, zone), levelUpHelper.GetServiceThreshhold((ItemClass.Level)(i - 1), zone), 7) + CalcProgress(buildingWealth, levelUpHelper.GetWealthThreshhold((ItemClass.Level)i, zone), levelUpHelper.GetWealthThreshhold((ItemClass.Level)(i - 1), zone), 8);
levelUp.educationProgress = 1 + CalcProgress((int)education, levelUpHelper.GetEducationThreshhold((ItemClass.Level)i, zone), levelUpHelper.GetEducationThreshhold((ItemClass.Level)(i - 1), zone), 15);
break;
}
}
levelUp.landValueTooLow = (serviceScore < levelUpHelper.GetServiceThreshhold((ItemClass.Level)(Math.Max(-1, (int)currentLevel - 2)), zone)) || (buildingWealth != 0 && buildingWealth < levelUpHelper.GetWealthThreshhold((ItemClass.Level)(Math.Max(-1, (int)currentLevel - 2)), zone));
if (targetLevel < currentLevel)
{
levelUp.landValueProgress = 1;
levelUp.educationProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.landValueProgress = 15;
levelUp.educationProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
return levelUp;
}
public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
if (Singleton <GameSpeedManager> .instance.values.IsHardMode)
{
return(originalMaintenanceCost * 5 / 4);
}
else
{
return(originalMaintenanceCost);
}
}
public override ResidentialLevelUp OnCalculateResidentialLevelUp(ResidentialLevelUp levelUp, int averageEducation, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
// Disable levelling up until I can look into land values
levelUp.landValueTooLow = false;
return levelUp;
}
public override CommercialLevelUp OnCalculateCommercialLevelUp(CommercialLevelUp levelUp, int averageWealth, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
return levelUp;
}
public override CommercialLevelUp OnCalculateCommercialLevelUp(CommercialLevelUp levelUp, int averageWealth, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
if (Hydrology.instance.isRaining == true && Hydrology.instance._preRainfallLandvalues[buildingID] > 0 && landValue > Hydrology.instance._preRainfallLandvalues[buildingID] && ModSettings.FreezeLandvalues == true)
{
//Debug.Log("[RF].LUEB Commercial Building " + buildingID.ToString() + " increased in Landvalue during a storm from " + Hydrology.instance._preRainfallLandvalues[buildingID].ToString() + " to " + landValue.ToString());
landValue = Hydrology.instance._preRainfallLandvalues[buildingID];
}
return(base.OnCalculateCommercialLevelUp(levelUp, averageWealth, landValue, buildingID, service, subService, currentLevel));
}
//Thread: Any
public int OnGetConstructionCost(int originalConstructionCost, Service service, SubService subService, Level level)
{
return originalConstructionCost;
}
//Thread: Any
public int OnGetRefundAmount(int constructionCost, int refundAmount, Service service, SubService subService, Level level)
{
return refundAmount;
}
// Thread: Simulation
public IndustrialLevelUp OnCalculateIndustrialLevelUp(IndustrialLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
return levelUp;
}
public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
if (SaveData2.saveData.DifficultyLevel < DifficultyLevel.Hard)
{
return originalMaintenanceCost;
}
var multiplier = 1.54;
if (SaveData2.saveData.DifficultyLevel == DifficultyLevel.DwarfFortress)
{
multiplier = 2.0;
}
switch (service)
{
case Service.FireDepartment:
case Service.PoliceDepartment:
case Service.HealthCare:
if (originalMaintenanceCost > 420000)
{
multiplier = 1.8;
}
break;
case Service.Education:
multiplier = 2.0;
if (SaveData2.saveData.DifficultyLevel == DifficultyLevel.DwarfFortress)
{
multiplier = 2.4;
}
break;
case Service.Road:
multiplier = 2.0;
if (SaveData2.saveData.DifficultyLevel == DifficultyLevel.DwarfFortress)
{
multiplier = 2.4;
}
break;
case Service.Garbage:
multiplier = 1;
break;
}
return (int)(originalMaintenanceCost * multiplier);
}
public override int OnGetConstructionCost(int originalConstructionCost, Service service, SubService subService, Level level)
{
if (service == Service.Education)
{
return((int)(originalConstructionCost * educationCostBonus));
}
else if (service == Service.HealthCare)
{
return((int)(originalConstructionCost * healthCareCostBonus));
}
else if (service == Service.Electricity)
{
return((int)(originalConstructionCost * electricityCostBonus));
}
else
{
return(base.OnGetConstructionCost(originalConstructionCost, service, subService, level));
}
}
public override int OnGetRelocationCost(int constructionCost, int relocationCost, Service service, SubService subService, Level level)
{
if (SaveData2.saveData.DifficultyLevel < DifficultyLevel.Hard)
{
return constructionCost;
}
return constructionCost / 2;
}
public override ResidentialLevelUp OnCalculateResidentialLevelUp(ResidentialLevelUp levelUp, int averageEducation, int landValue, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
if (levelUp.landValueProgress != 0)
{
Level targetLevel;
if (landValue < 15)
{
targetLevel = Level.Level1;
levelUp.landValueProgress = 1 + (landValue * 15 + 7) / 15;
}
else if (landValue < 35)
{
targetLevel = Level.Level2;
levelUp.landValueProgress = 1 + ((landValue - 15) * 15 + 10) / 20;
}
else if (landValue < 60)
{
targetLevel = Level.Level3;
levelUp.landValueProgress = 1 + ((landValue - 35) * 15 + 12) / 25;
}
else if (landValue < 85)
{
targetLevel = Level.Level4;
levelUp.landValueProgress = 1 + ((landValue - 60) * 15 + 12) / 25;
}
else
{
targetLevel = Level.Level5;
levelUp.landValueProgress = 1;
}
if (targetLevel < currentLevel)
{
levelUp.landValueProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.landValueProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
}
levelUp.landValueTooLow = false;
if (currentLevel == Level.Level2)
{
if (landValue == 0) levelUp.landValueTooLow = true;
}
else if (currentLevel == Level.Level3)
{
if (landValue < 21) levelUp.landValueTooLow = true;
}
else if (currentLevel == Level.Level4)
{
if (landValue < 46) levelUp.landValueTooLow = true;
}
else if (currentLevel == Level.Level5)
{
if (landValue < 71) levelUp.landValueTooLow = true;
}
return levelUp;
}
public override OfficeLevelUp OnCalculateOfficeLevelUp(OfficeLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
if (SaveData2.saveData.DifficultyLevel == DifficultyLevel.Vanilla)
{
return levelUp;
}
var instance = Singleton<BuildingManager>.instance.m_buildings.m_buffer[(int)buildingID];
var zone = instance.Info.m_class.GetZone();
float education = 0;
float happy = 0;
float commute = 0;
var levelUpHelper = LevelUpHelper3.instance;
serviceScore = levelUpHelper.GetProperServiceScore(buildingID);
levelUpHelper.GetEducationHappyScore(buildingID, out education, out happy, out commute);
Level targetLevel = Level.Level3;
for (var i = 0; i < 3; i += 1)
{
if (serviceScore < levelUpHelper.GetServiceThreshhold((ItemClass.Level)i, zone) || education < levelUpHelper.GetEducationThreshhold((ItemClass.Level)i, zone))
{
targetLevel = (Level)i;
levelUp.serviceProgress = 1 + CalcProgress(serviceScore, levelUpHelper.GetServiceThreshhold((ItemClass.Level)i, ItemClass.Zone.Office), levelUpHelper.GetServiceThreshhold((ItemClass.Level)(i - 1), ItemClass.Zone.Office), 15);
levelUp.educationProgress = 1 + CalcProgress((int)education, levelUpHelper.GetEducationThreshhold((ItemClass.Level)i, zone), levelUpHelper.GetEducationThreshhold((ItemClass.Level)(i - 1), zone), 15);
break;
}
}
levelUp.tooFewServices = (serviceScore < levelUpHelper.GetServiceThreshhold((ItemClass.Level)(Math.Max(-1, (int)currentLevel - 2)), zone));
if (targetLevel < currentLevel)
{
levelUp.serviceProgress = 1;
levelUp.educationProgress = 1;
}
else if (targetLevel > currentLevel)
{
levelUp.serviceProgress = 15;
levelUp.educationProgress = 15;
}
if (targetLevel < levelUp.targetLevel)
{
levelUp.targetLevel = targetLevel;
}
return levelUp;
}
//Thread: Any
public int OnGetRelocationCost(int constructionCost, int relocationCost, Service service, SubService subService, Level level)
{
return relocationCost;
}
public override int OnGetConstructionCost(int originalConstructionCost, Service service, SubService subService, Level level)
{
return(originalConstructionCost * 9 / 10);
}
//Thread: Any
public int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
return originalMaintenanceCost;
}
public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
return(originalMaintenanceCost * 9 / 10);
}
//Thread: Simulation
public int OnFetchResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
return amount;
}
public override int OnGetRelocationCost(int constructionCost, int relocationCost, Service service, SubService subService, Level level)
{
return(0);
}
/// <summary>
/// Fires when for example a building cost is withdrawed.
/// </summary>
/// <param name="resource"></param>
/// <param name="amount"></param>
/// <param name="service"></param>
/// <param name="subService"></param>
/// <param name="level"></param>
/// <returns></returns>
public override int OnFetchResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
MPCashChangeAmount += base.OnFetchResource(resource, amount, service, subService, level);
return(base.OnFetchResource(resource, amount, service, subService, level));
}
public override int OnGetRefundAmount(int constructionCost, int refundAmount, Service service, SubService subService, Level level)
{
return(constructionCost);
}
public override OfficeLevelUp OnCalculateOfficeLevelUp(OfficeLevelUp levelUp, int averageEducation, int serviceScore, ushort buildingID, Service service, SubService subService, Level currentLevel)
{
return levelUp;
}
public override int OnAddResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
switch (MultiplayerManager.Instance.CurrentRole)
{
case MultiplayerRole.Client:
{
typeof(EconomyManager).GetField("m_taxMultiplier", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(Singleton <EconomyManager> .instance, 0);
break;
}
}
return(amount);
}
public override int OnGetConstructionCost(int originalConstructionCost, Service service, SubService subService, Level level)
{
GameSpeedManager gs = Singleton <GameSpeedManager> .instance;
return(originalConstructionCost * gs.Parameters.ConstructionCostMultiplier);
}
public override int OnGetMaintenanceCost(int originalMaintenanceCost, Service service, SubService subService, Level level)
{
switch (MultiplayerManager.Instance.CurrentRole)
{
case MultiplayerRole.Client:
{
return(0);
}
case MultiplayerRole.Server:
{
return(originalMaintenanceCost);
}
}
return(originalMaintenanceCost);
}
public override int OnAddResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
if (resource == EconomyResource.RewardAmount)
{
if (Singleton <GameSpeedManager> .instance.values.IsHardMode)
{
return(0);
}
}
return(amount);
}
/// <summary>
/// Fires when for example a building cost is withdrawed.
/// </summary>
/// <param name="resource"></param>
/// <param name="amount"></param>
/// <param name="service"></param>
/// <param name="subService"></param>
/// <param name="level"></param>
/// <returns></returns>
public override int OnFetchResource(EconomyResource resource, int amount, Service service, SubService subService, Level level)
{
MPCashChangeAmount += base.OnFetchResource(resource, amount, service, subService, level);
return base.OnFetchResource(resource, amount, service, subService, level);
}
