bitburner-src/src/Corporation/Industry.ts

1455 lines
55 KiB
TypeScript
Raw Normal View History

2021-09-25 20:42:57 +02:00
import { Reviver, Generic_toJSON, Generic_fromJSON } from "../utils/JSONReviver";
2021-08-31 08:49:57 +02:00
import { CityName } from "../Locations/data/CityNames";
2021-09-09 05:47:34 +02:00
import { Industries, IndustryStartingCosts, IndustryResearchTrees } from "./IndustryData";
2021-08-31 08:49:57 +02:00
import { CorporationConstants } from "./data/Constants";
import { EmployeePositions } from "./EmployeePositions";
import { Material } from "./Material";
2021-09-25 20:42:57 +02:00
import { getRandomInt } from "../utils/helpers/getRandomInt";
2021-08-31 08:49:57 +02:00
import { calculateEffectWithFactors } from "../utils/calculateEffectWithFactors";
import { OfficeSpace } from "./OfficeSpace";
import { Product } from "./Product";
2021-09-25 20:42:57 +02:00
import { dialogBoxCreate } from "../ui/React/DialogBox";
import { isString } from "../utils/helpers/isString";
2021-08-31 08:49:57 +02:00
import { MaterialSizes } from "./MaterialSizes";
import { Warehouse } from "./Warehouse";
2021-08-31 09:39:04 +02:00
import { ICorporation } from "./ICorporation";
2021-08-31 20:47:07 +02:00
import { IIndustry } from "./IIndustry";
2021-09-05 01:09:30 +02:00
import { IndustryUpgrade, IndustryUpgrades } from "./IndustryUpgrades";
2021-08-31 08:49:57 +02:00
interface IParams {
2021-09-05 01:09:30 +02:00
name?: string;
corp?: ICorporation;
type?: string;
2021-08-31 08:49:57 +02:00
}
2021-08-31 20:47:07 +02:00
export class Industry implements IIndustry {
2021-09-05 01:09:30 +02:00
name = "";
type = Industries.Agriculture;
sciResearch = new Material({ name: "Scientific Research" });
researched: { [key: string]: boolean | undefined } = {};
reqMats: { [key: string]: number | undefined } = {};
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
//An array of the name of materials being produced
prodMats: string[] = [];
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
products: { [key: string]: Product | undefined } = {};
makesProducts = false;
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
awareness = 0;
popularity = 0; //Should always be less than awareness
startingCost = 0;
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
/* The following are factors for how much production/other things are increased by
2021-08-31 08:49:57 +02:00
different factors. The production increase always has diminishing returns,
and they are all reprsented by exponentials of < 1 (e.g x ^ 0.5, x ^ 0.8)
The number for these represent the exponential. A lower number means more
diminishing returns */
2021-09-05 01:09:30 +02:00
reFac = 0; //Real estate Factor
sciFac = 0; //Scientific Research Factor, affects quality
hwFac = 0; //Hardware factor
robFac = 0; //Robotics Factor
aiFac = 0; //AI Cores factor;
advFac = 0; //Advertising factor, affects sales
prodMult = 0; //Production multiplier
//Financials
2021-11-12 03:35:26 +01:00
lastCycleRevenue: number;
lastCycleExpenses: number;
thisCycleRevenue: number;
thisCycleExpenses: number;
2021-09-05 01:09:30 +02:00
//Upgrades
upgrades: number[] = Array(Object.keys(IndustryUpgrades).length).fill(0);
state = "START";
newInd = true;
//Maps locations to warehouses. 0 if no warehouse at that location
warehouses: { [key: string]: Warehouse | 0 };
//Maps locations to offices. 0 if no office at that location
offices: { [key: string]: OfficeSpace | 0 } = {
[CityName.Aevum]: 0,
[CityName.Chongqing]: 0,
[CityName.Sector12]: new OfficeSpace({
loc: CityName.Sector12,
size: CorporationConstants.OfficeInitialSize,
}),
[CityName.NewTokyo]: 0,
[CityName.Ishima]: 0,
[CityName.Volhaven]: 0,
};
constructor(params: IParams = {}) {
this.name = params.name ? params.name : "";
this.type = params.type ? params.type : Industries.Agriculture;
2021-08-31 08:49:57 +02:00
//Financials
2021-11-12 03:35:26 +01:00
this.lastCycleRevenue = 0;
this.lastCycleExpenses = 0;
this.thisCycleRevenue = 0;
this.thisCycleExpenses = 0;
2021-09-05 01:09:30 +02:00
this.warehouses = {
[CityName.Aevum]: 0,
[CityName.Chongqing]: 0,
[CityName.Sector12]: new Warehouse({
corp: params.corp,
industry: this,
loc: CityName.Sector12,
size: CorporationConstants.WarehouseInitialSize,
}),
[CityName.NewTokyo]: 0,
[CityName.Ishima]: 0,
[CityName.Volhaven]: 0,
2021-08-31 08:49:57 +02:00
};
2021-09-05 01:09:30 +02:00
this.init();
}
init(): void {
//Set the unique properties of an industry (how much its affected by real estate/scientific research, etc.)
const startingCost = IndustryStartingCosts[this.type];
2021-09-09 05:47:34 +02:00
if (startingCost === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.startingCost = startingCost;
switch (this.type) {
case Industries.Energy:
this.reFac = 0.65;
this.sciFac = 0.7;
this.robFac = 0.05;
this.aiFac = 0.3;
this.advFac = 0.08;
this.reqMats = {
Hardware: 0.1,
Metal: 0.2,
2021-08-31 08:49:57 +02:00
};
2021-09-05 01:09:30 +02:00
this.prodMats = ["Energy"];
break;
case Industries.Utilities:
case "Utilities":
this.reFac = 0.5;
this.sciFac = 0.6;
this.robFac = 0.4;
this.aiFac = 0.4;
this.advFac = 0.08;
this.reqMats = {
Hardware: 0.1,
Metal: 0.1,
};
this.prodMats = ["Water"];
break;
case Industries.Agriculture:
this.reFac = 0.72;
this.sciFac = 0.5;
this.hwFac = 0.2;
this.robFac = 0.3;
this.aiFac = 0.3;
this.advFac = 0.04;
this.reqMats = {
Water: 0.5,
Energy: 0.5,
};
this.prodMats = ["Plants", "Food"];
break;
case Industries.Fishing:
this.reFac = 0.15;
this.sciFac = 0.35;
this.hwFac = 0.35;
this.robFac = 0.5;
this.aiFac = 0.2;
this.advFac = 0.08;
this.reqMats = {
Energy: 0.5,
};
this.prodMats = ["Food"];
break;
case Industries.Mining:
this.reFac = 0.3;
this.sciFac = 0.26;
this.hwFac = 0.4;
this.robFac = 0.45;
this.aiFac = 0.45;
this.advFac = 0.06;
this.reqMats = {
Energy: 0.8,
};
this.prodMats = ["Metal"];
break;
case Industries.Food:
//reFac is unique for this bc it diminishes greatly per city. Handle this separately in code?
this.sciFac = 0.12;
this.hwFac = 0.15;
this.robFac = 0.3;
this.aiFac = 0.25;
this.advFac = 0.25;
this.reFac = 0.05;
this.reqMats = {
Food: 0.5,
Water: 0.5,
Energy: 0.2,
};
this.makesProducts = true;
break;
case Industries.Tobacco:
this.reFac = 0.15;
this.sciFac = 0.75;
this.hwFac = 0.15;
this.robFac = 0.2;
this.aiFac = 0.15;
this.advFac = 0.2;
this.reqMats = {
Plants: 1,
Water: 0.2,
};
this.makesProducts = true;
break;
case Industries.Chemical:
this.reFac = 0.25;
this.sciFac = 0.75;
this.hwFac = 0.2;
this.robFac = 0.25;
this.aiFac = 0.2;
this.advFac = 0.07;
this.reqMats = {
Plants: 1,
Energy: 0.5,
Water: 0.5,
};
this.prodMats = ["Chemicals"];
break;
case Industries.Pharmaceutical:
this.reFac = 0.05;
this.sciFac = 0.8;
this.hwFac = 0.15;
this.robFac = 0.25;
this.aiFac = 0.2;
this.advFac = 0.16;
this.reqMats = {
Chemicals: 2,
Energy: 1,
Water: 0.5,
};
this.prodMats = ["Drugs"];
this.makesProducts = true;
break;
case Industries.Computer:
case "Computer":
this.reFac = 0.2;
this.sciFac = 0.62;
this.robFac = 0.36;
this.aiFac = 0.19;
this.advFac = 0.17;
this.reqMats = {
Metal: 2,
Energy: 1,
};
this.prodMats = ["Hardware"];
this.makesProducts = true;
break;
case Industries.Robotics:
this.reFac = 0.32;
this.sciFac = 0.65;
this.aiFac = 0.36;
this.advFac = 0.18;
this.hwFac = 0.19;
this.reqMats = {
Hardware: 5,
Energy: 3,
};
this.prodMats = ["Robots"];
this.makesProducts = true;
break;
case Industries.Software:
this.sciFac = 0.62;
this.advFac = 0.16;
this.hwFac = 0.25;
this.reFac = 0.15;
this.aiFac = 0.18;
this.robFac = 0.05;
this.reqMats = {
Hardware: 0.5,
Energy: 0.5,
};
this.prodMats = ["AICores"];
this.makesProducts = true;
break;
case Industries.Healthcare:
this.reFac = 0.1;
this.sciFac = 0.75;
this.advFac = 0.11;
this.hwFac = 0.1;
this.robFac = 0.1;
this.aiFac = 0.1;
this.reqMats = {
Robots: 10,
AICores: 5,
Energy: 5,
Water: 5,
};
this.makesProducts = true;
break;
case Industries.RealEstate:
this.robFac = 0.6;
this.aiFac = 0.6;
this.advFac = 0.25;
this.sciFac = 0.05;
this.hwFac = 0.05;
this.reqMats = {
Metal: 5,
Energy: 5,
Water: 2,
Hardware: 4,
};
this.prodMats = ["RealEstate"];
this.makesProducts = true;
break;
default:
2021-09-09 05:47:34 +02:00
console.error(`Invalid Industry Type passed into Industry.init(): ${this.type}`);
2021-09-05 01:09:30 +02:00
return;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
getProductDescriptionText(): string {
if (!this.makesProducts) return "";
switch (this.type) {
case Industries.Food:
return "create and manage restaurants";
case Industries.Tobacco:
return "create tobacco and tobacco-related products";
case Industries.Pharmaceutical:
return "develop new pharmaceutical drugs";
case Industries.Computer:
case "Computer":
return "create new computer hardware and networking infrastructures";
case Industries.Robotics:
return "build specialized robots and robot-related products";
case Industries.Software:
return "develop computer software";
case Industries.Healthcare:
return "build and manage hospitals";
case Industries.RealEstate:
return "develop and manage real estate properties";
default:
2021-09-09 05:47:34 +02:00
console.error("Invalid industry type in Industry.getProductDescriptionText");
2021-09-05 01:09:30 +02:00
return "";
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
getMaximumNumberProducts(): number {
if (!this.makesProducts) return 0;
// Calculate additional number of allowed Products from Research/Upgrades
let additional = 0;
if (this.hasResearch("uPgrade: Capacity.I")) ++additional;
if (this.hasResearch("uPgrade: Capacity.II")) ++additional;
return CorporationConstants.BaseMaxProducts + additional;
}
hasMaximumNumberProducts(): boolean {
return Object.keys(this.products).length >= this.getMaximumNumberProducts();
}
//Calculates the values that factor into the production and properties of
//materials/products (such as quality, etc.)
calculateProductionFactors(): void {
let multSum = 0;
for (let i = 0; i < CorporationConstants.Cities.length; ++i) {
const city = CorporationConstants.Cities[i];
const warehouse = this.warehouses[city];
if (!(warehouse instanceof Warehouse)) {
continue;
}
const materials = warehouse.materials;
const cityMult =
Math.pow(0.002 * materials.RealEstate.qty + 1, this.reFac) *
Math.pow(0.002 * materials.Hardware.qty + 1, this.hwFac) *
Math.pow(0.002 * materials.Robots.qty + 1, this.robFac) *
Math.pow(0.002 * materials.AICores.qty + 1, this.aiFac);
multSum += Math.pow(cityMult, 0.73);
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
multSum < 1 ? (this.prodMult = 1) : (this.prodMult = multSum);
}
updateWarehouseSizeUsed(warehouse: Warehouse): void {
warehouse.updateMaterialSizeUsed();
2022-01-16 01:45:03 +01:00
for (const prodName of Object.keys(this.products)) {
2021-09-05 01:09:30 +02:00
if (this.products.hasOwnProperty(prodName)) {
const prod = this.products[prodName];
if (prod === undefined) continue;
warehouse.sizeUsed += prod.data[warehouse.loc][0] * prod.siz;
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
process(marketCycles = 1, state: string, corporation: ICorporation): void {
this.state = state;
//At the start of a cycle, store and reset revenue/expenses
//Then calculate salaries and processs the markets
if (state === "START") {
if (isNaN(this.thisCycleRevenue) || isNaN(this.thisCycleExpenses)) {
console.error("NaN in Corporation's computed revenue/expenses");
dialogBoxCreate(
"Something went wrong when compting Corporation's revenue/expenses. This is a bug. Please report to game developer",
);
2021-11-12 03:35:26 +01:00
this.thisCycleRevenue = 0;
this.thisCycleExpenses = 0;
2021-09-05 01:09:30 +02:00
}
2021-11-12 03:35:26 +01:00
this.lastCycleRevenue = this.thisCycleRevenue / (marketCycles * CorporationConstants.SecsPerMarketCycle);
this.lastCycleExpenses = this.thisCycleExpenses / (marketCycles * CorporationConstants.SecsPerMarketCycle);
this.thisCycleRevenue = 0;
this.thisCycleExpenses = 0;
2021-09-05 01:09:30 +02:00
// Once you start making revenue, the player should no longer be
// considered new, and therefore no longer needs the 'tutorial' UI elements
2021-11-12 03:35:26 +01:00
if (this.lastCycleRevenue > 0) {
2021-09-05 01:09:30 +02:00
this.newInd = false;
}
// Process offices (and the employees in them)
let employeeSalary = 0;
2022-01-16 01:45:03 +01:00
for (const officeLoc of Object.keys(this.offices)) {
2021-09-05 01:09:30 +02:00
const office = this.offices[officeLoc];
if (office === 0) continue;
if (office instanceof OfficeSpace) {
employeeSalary += office.process(marketCycles, corporation, this);
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
2021-11-12 03:35:26 +01:00
this.thisCycleExpenses = this.thisCycleExpenses + employeeSalary;
2021-09-05 01:09:30 +02:00
// Process change in demand/competition of materials/products
this.processMaterialMarket();
this.processProductMarket(marketCycles);
// Process loss of popularity
this.popularity -= marketCycles * 0.0001;
this.popularity = Math.max(0, this.popularity);
// Process Dreamsense gains
const popularityGain = corporation.getDreamSenseGain(),
awarenessGain = popularityGain * 4;
if (popularityGain > 0) {
2022-01-14 11:05:00 +01:00
const awareness = this.awareness + (awarenessGain * marketCycles);
this.awareness = Math.min(awareness, Number.MAX_VALUE);
const popularity = this.popularity + (popularityGain * marketCycles);
this.popularity = Math.min(popularity, Number.MAX_VALUE);
2021-09-05 01:09:30 +02:00
}
return;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
// Process production, purchase, and import/export of materials
let res = this.processMaterials(marketCycles, corporation);
if (Array.isArray(res)) {
2021-11-12 03:35:26 +01:00
this.thisCycleRevenue = this.thisCycleRevenue + res[0];
this.thisCycleExpenses = this.thisCycleExpenses + res[1];
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
// Process creation, production & sale of products
res = this.processProducts(marketCycles, corporation);
if (Array.isArray(res)) {
2021-11-12 03:35:26 +01:00
this.thisCycleRevenue = this.thisCycleRevenue + res[0];
this.thisCycleExpenses = this.thisCycleExpenses + res[1];
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
// Process change in demand and competition for this industry's materials
processMaterialMarket(): void {
//References to prodMats and reqMats
const reqMats = this.reqMats,
prodMats = this.prodMats;
//Only 'process the market' for materials that this industry deals with
for (let i = 0; i < CorporationConstants.Cities.length; ++i) {
//If this industry has a warehouse in this city, process the market
//for every material this industry requires or produces
2021-09-09 05:47:34 +02:00
if (this.warehouses[CorporationConstants.Cities[i]] instanceof Warehouse) {
2021-09-05 01:09:30 +02:00
const wh = this.warehouses[CorporationConstants.Cities[i]];
if (wh === 0) continue;
2022-01-16 01:45:03 +01:00
for (const name of Object.keys(reqMats)) {
2021-09-05 01:09:30 +02:00
if (reqMats.hasOwnProperty(name)) {
wh.materials[name].processMarket();
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
//Produced materials are stored in an array
for (let foo = 0; foo < prodMats.length; ++foo) {
wh.materials[prodMats[foo]].processMarket();
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
//Process these twice because these boost production
wh.materials["Hardware"].processMarket();
wh.materials["Robots"].processMarket();
wh.materials["AICores"].processMarket();
wh.materials["RealEstate"].processMarket();
}
}
}
// Process change in demand and competition for this industry's products
processProductMarket(marketCycles = 1): void {
// Demand gradually decreases, and competition gradually increases
2022-01-16 01:45:03 +01:00
for (const name of Object.keys(this.products)) {
2021-09-05 01:09:30 +02:00
if (this.products.hasOwnProperty(name)) {
const product = this.products[name];
if (product === undefined) continue;
let change = getRandomInt(0, 3) * 0.0004;
if (change === 0) continue;
if (
this.type === Industries.Pharmaceutical ||
this.type === Industries.Software ||
this.type === Industries.Robotics
) {
change *= 3;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
change *= marketCycles;
product.dmd -= change;
product.cmp += change;
product.cmp = Math.min(product.cmp, 99.99);
product.dmd = Math.max(product.dmd, 0.001);
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
//Process production, purchase, and import/export of materials
2021-09-09 05:47:34 +02:00
processMaterials(marketCycles = 1, corporation: ICorporation): [number, number] {
2021-09-05 01:09:30 +02:00
let revenue = 0,
expenses = 0;
this.calculateProductionFactors();
//At the start of the export state, set the imports of everything to 0
if (this.state === "EXPORT") {
for (let i = 0; i < CorporationConstants.Cities.length; ++i) {
const city = CorporationConstants.Cities[i];
if (!(this.warehouses[city] instanceof Warehouse)) {
continue;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
const warehouse = this.warehouses[city];
if (warehouse === 0) continue;
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(warehouse.materials)) {
2021-09-05 01:09:30 +02:00
if (warehouse.materials.hasOwnProperty(matName)) {
const mat = warehouse.materials[matName];
mat.imp = 0;
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
for (let i = 0; i < CorporationConstants.Cities.length; ++i) {
const city = CorporationConstants.Cities[i];
const office = this.offices[city];
if (office === 0) continue;
if (this.warehouses[city] instanceof Warehouse) {
const warehouse = this.warehouses[city];
if (warehouse === 0) continue;
switch (this.state) {
2021-09-07 07:14:55 +02:00
case "PURCHASE": {
2021-09-05 01:09:30 +02:00
/* Process purchase of materials */
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(warehouse.materials)) {
2021-09-07 07:14:55 +02:00
if (!warehouse.materials.hasOwnProperty(matName)) continue;
const mat = warehouse.materials[matName];
let buyAmt = 0;
let maxAmt = 0;
2021-09-09 05:47:34 +02:00
if (warehouse.smartSupplyEnabled && Object.keys(this.reqMats).includes(matName)) {
2021-09-07 07:14:55 +02:00
continue;
2021-09-05 01:09:30 +02:00
}
2021-09-09 05:47:34 +02:00
buyAmt = mat.buy * CorporationConstants.SecsPerMarketCycle * marketCycles;
2021-09-07 07:14:55 +02:00
2021-10-28 06:06:57 +02:00
maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / MaterialSizes[matName]);
2021-09-07 07:14:55 +02:00
buyAmt = Math.min(buyAmt, maxAmt);
if (buyAmt > 0) {
mat.qty += buyAmt;
expenses += buyAmt * mat.bCost;
}
this.updateWarehouseSizeUsed(warehouse);
2021-09-05 01:09:30 +02:00
} //End process purchase of materials
2021-09-07 07:14:55 +02:00
// smart supply
const smartBuy: { [key: string]: number | undefined } = {};
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(warehouse.materials)) {
2021-09-07 07:14:55 +02:00
if (!warehouse.materials.hasOwnProperty(matName)) continue;
2021-09-09 05:47:34 +02:00
if (!warehouse.smartSupplyEnabled || !Object.keys(this.reqMats).includes(matName)) continue;
2021-09-07 07:14:55 +02:00
const mat = warehouse.materials[matName];
//Smart supply tracker is stored as per second rate
const reqMat = this.reqMats[matName];
2021-09-09 05:47:34 +02:00
if (reqMat === undefined) throw new Error(`reqMat "${matName}" is undefined`);
2021-09-07 07:14:55 +02:00
mat.buy = reqMat * warehouse.smartSupplyStore;
2021-09-09 05:47:34 +02:00
let buyAmt = mat.buy * CorporationConstants.SecsPerMarketCycle * marketCycles;
const maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / MaterialSizes[matName]);
2021-09-07 07:14:55 +02:00
buyAmt = Math.min(buyAmt, maxAmt);
if (buyAmt > 0) smartBuy[matName] = buyAmt;
}
// Find which material were trying to create the least amount of product with.
let worseAmt = 1e99;
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(smartBuy)) {
2021-09-07 07:14:55 +02:00
const buyAmt = smartBuy[matName];
2021-09-09 05:47:34 +02:00
if (buyAmt === undefined) throw new Error(`Somehow smartbuy matname is undefined`);
2021-09-07 07:14:55 +02:00
const reqMat = this.reqMats[matName];
2021-09-09 05:47:34 +02:00
if (reqMat === undefined) throw new Error(`reqMat "${matName}" is undefined`);
2021-09-07 07:14:55 +02:00
const amt = buyAmt / reqMat;
if (amt < worseAmt) worseAmt = amt;
}
// Align all the materials to the smallest amount.
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(smartBuy)) {
2021-09-07 07:14:55 +02:00
const reqMat = this.reqMats[matName];
2021-09-09 05:47:34 +02:00
if (reqMat === undefined) throw new Error(`reqMat "${matName}" is undefined`);
2021-09-07 07:14:55 +02:00
smartBuy[matName] = worseAmt * reqMat;
}
// Calculate the total size of all things were trying to buy
let totalSize = 0;
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(smartBuy)) {
2021-09-07 07:14:55 +02:00
const buyAmt = smartBuy[matName];
2021-09-09 05:47:34 +02:00
if (buyAmt === undefined) throw new Error(`Somehow smartbuy matname is undefined`);
2021-09-07 07:14:55 +02:00
totalSize += buyAmt * MaterialSizes[matName];
}
// Shrink to the size of available space.
const freeSpace = warehouse.size - warehouse.sizeUsed;
if (totalSize > freeSpace) {
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(smartBuy)) {
2021-09-07 07:14:55 +02:00
const buyAmt = smartBuy[matName];
2021-09-09 05:47:34 +02:00
if (buyAmt === undefined) throw new Error(`Somehow smartbuy matname is undefined`);
smartBuy[matName] = Math.floor((buyAmt * freeSpace) / totalSize);
2021-09-07 07:14:55 +02:00
}
}
// Use the materials already in the warehouse if the option is on.
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(smartBuy)) {
if (!warehouse.smartSupplyUseLeftovers[matName]) continue;
2021-09-07 07:14:55 +02:00
const mat = warehouse.materials[matName];
const buyAmt = smartBuy[matName];
2021-09-09 05:47:34 +02:00
if (buyAmt === undefined) throw new Error(`Somehow smartbuy matname is undefined`);
2021-09-07 07:14:55 +02:00
smartBuy[matName] = Math.max(0, buyAmt - mat.qty);
}
// buy them
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(smartBuy)) {
2021-09-07 07:14:55 +02:00
const mat = warehouse.materials[matName];
const buyAmt = smartBuy[matName];
2021-09-09 05:47:34 +02:00
if (buyAmt === undefined) throw new Error(`Somehow smartbuy matname is undefined`);
2021-09-07 07:14:55 +02:00
mat.qty += buyAmt;
expenses += buyAmt * mat.bCost;
}
break;
}
2021-09-05 01:09:30 +02:00
case "PRODUCTION":
warehouse.smartSupplyStore = 0; //Reset smart supply amount
/* Process production of materials */
if (this.prodMats.length > 0) {
const mat = warehouse.materials[this.prodMats[0]];
//Calculate the maximum production of this material based
//on the office's productivity
const maxProd =
this.getOfficeProductivity(office) *
this.prodMult * // Multiplier from materials
corporation.getProductionMultiplier() *
this.getProductionMultiplier(); // Multiplier from Research
let prod;
if (mat.prdman[0]) {
//Production is manually limited
prod = Math.min(maxProd, mat.prdman[1]);
} else {
prod = maxProd;
}
prod *= CorporationConstants.SecsPerMarketCycle * marketCycles; //Convert production from per second to per market cycle
// Calculate net change in warehouse storage making the produced materials will cost
let totalMatSize = 0;
for (let tmp = 0; tmp < this.prodMats.length; ++tmp) {
totalMatSize += MaterialSizes[this.prodMats[tmp]];
}
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(this.reqMats)) {
2021-09-05 01:09:30 +02:00
const normQty = this.reqMats[reqMatName];
if (normQty === undefined) continue;
totalMatSize -= MaterialSizes[reqMatName] * normQty;
}
// If not enough space in warehouse, limit the amount of produced materials
if (totalMatSize > 0) {
2021-09-09 05:47:34 +02:00
const maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / totalMatSize);
2021-09-05 01:09:30 +02:00
prod = Math.min(maxAmt, prod);
}
if (prod < 0) {
prod = 0;
}
// Keep track of production for smart supply (/s)
2021-09-09 05:47:34 +02:00
warehouse.smartSupplyStore += prod / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-09-05 01:09:30 +02:00
// Make sure we have enough resource to make our materials
let producableFrac = 1;
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(this.reqMats)) {
2021-09-05 01:09:30 +02:00
if (this.reqMats.hasOwnProperty(reqMatName)) {
const reqMat = this.reqMats[reqMatName];
if (reqMat === undefined) continue;
const req = reqMat * prod;
if (warehouse.materials[reqMatName].qty < req) {
2021-09-09 05:47:34 +02:00
producableFrac = Math.min(producableFrac, warehouse.materials[reqMatName].qty / req);
2021-09-05 01:09:30 +02:00
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
if (producableFrac <= 0) {
producableFrac = 0;
prod = 0;
}
// Make our materials if they are producable
if (producableFrac > 0 && prod > 0) {
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(this.reqMats)) {
2021-09-05 01:09:30 +02:00
const reqMat = this.reqMats[reqMatName];
if (reqMat === undefined) continue;
const reqMatQtyNeeded = reqMat * prod * producableFrac;
warehouse.materials[reqMatName].qty -= reqMatQtyNeeded;
warehouse.materials[reqMatName].prd = 0;
warehouse.materials[reqMatName].prd -=
2021-09-09 05:47:34 +02:00
reqMatQtyNeeded / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
for (let j = 0; j < this.prodMats.length; ++j) {
2021-09-09 05:47:34 +02:00
warehouse.materials[this.prodMats[j]].qty += prod * producableFrac;
2021-09-05 01:09:30 +02:00
warehouse.materials[this.prodMats[j]].qlt =
office.employeeProd[EmployeePositions.Engineer] / 90 +
Math.pow(this.sciResearch.qty, this.sciFac) +
2021-09-09 05:47:34 +02:00
Math.pow(warehouse.materials["AICores"].qty, this.aiFac) / 10e3;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
} else {
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(this.reqMats)) {
2021-09-05 01:09:30 +02:00
if (this.reqMats.hasOwnProperty(reqMatName)) {
warehouse.materials[reqMatName].prd = 0;
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
//Per second
2021-09-09 05:47:34 +02:00
const fooProd = (prod * producableFrac) / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-09-05 01:09:30 +02:00
for (let fooI = 0; fooI < this.prodMats.length; ++fooI) {
warehouse.materials[this.prodMats[fooI]].prd = fooProd;
}
} else {
//If this doesn't produce any materials, then it only creates
//Products. Creating products will consume materials. The
//Production of all consumed materials must be set to 0
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(this.reqMats)) {
2021-09-05 01:09:30 +02:00
warehouse.materials[reqMatName].prd = 0;
}
}
break;
case "SALE":
/* Process sale of materials */
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(warehouse.materials)) {
2021-09-05 01:09:30 +02:00
if (warehouse.materials.hasOwnProperty(matName)) {
const mat = warehouse.materials[matName];
if (mat.sCost < 0 || mat.sllman[0] === false) {
mat.sll = 0;
continue;
2021-08-31 08:49:57 +02:00
}
// Sale multipliers
2021-09-05 01:09:30 +02:00
const businessFactor = this.getBusinessFactor(office); //Business employee productivity
const advertisingFactor = this.getAdvertisingFactors()[0]; //Awareness + popularity
const marketFactor = this.getMarketFactor(mat); //Competition + demand
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
// Determine the cost that the material will be sold at
const markupLimit = mat.getMarkupLimit();
2021-08-31 09:07:20 +02:00
let sCost;
2021-09-05 01:09:30 +02:00
if (mat.marketTa2) {
const prod = mat.prd;
// Reverse engineer the 'maxSell' formula
// 1. Set 'maxSell' = prod
// 2. Substitute formula for 'markup'
// 3. Solve for 'sCost'
const numerator = markupLimit;
const sqrtNumerator = prod;
const sqrtDenominator =
(mat.qlt + 0.001) *
marketFactor *
businessFactor *
corporation.getSalesMultiplier() *
advertisingFactor *
this.getSalesMultiplier();
2021-09-09 05:47:34 +02:00
const denominator = Math.sqrt(sqrtNumerator / sqrtDenominator);
2021-09-05 01:09:30 +02:00
let optimalPrice;
if (sqrtDenominator === 0 || denominator === 0) {
if (sqrtNumerator === 0) {
optimalPrice = 0; // No production
2021-08-31 08:49:57 +02:00
} else {
2021-09-05 01:09:30 +02:00
optimalPrice = mat.bCost + markupLimit;
2021-09-09 05:47:34 +02:00
console.warn(`In Corporation, found illegal 0s when trying to calculate MarketTA2 sale cost`);
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
} else {
optimalPrice = numerator / denominator + mat.bCost;
}
// We'll store this "Optimal Price" in a property so that we don't have
// to re-calculate it for the UI
mat.marketTa2Price = optimalPrice;
sCost = optimalPrice;
} else if (mat.marketTa1) {
sCost = mat.bCost + markupLimit;
} else if (isString(mat.sCost)) {
sCost = (mat.sCost as string).replace(/MP/g, mat.bCost + "");
sCost = eval(sCost);
2021-08-31 08:49:57 +02:00
} else {
2021-09-05 01:09:30 +02:00
sCost = mat.sCost;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
// Calculate how much of the material sells (per second)
2021-08-31 09:07:20 +02:00
let markup = 1;
2021-09-05 01:09:30 +02:00
if (sCost > mat.bCost) {
//Penalty if difference between sCost and bCost is greater than markup limit
if (sCost - mat.bCost > markupLimit) {
markup = Math.pow(markupLimit / (sCost - mat.bCost), 2);
}
} else if (sCost < mat.bCost) {
if (sCost <= 0) {
markup = 1e12; //Sell everything, essentially discard
} else {
//Lower prices than market increases sales
markup = mat.bCost / sCost;
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
const maxSell =
(mat.qlt + 0.001) *
marketFactor *
markup *
businessFactor *
corporation.getSalesMultiplier() *
advertisingFactor *
this.getSalesMultiplier();
2021-08-31 09:07:20 +02:00
let sellAmt;
2021-09-05 01:09:30 +02:00
if (isString(mat.sllman[1])) {
//Dynamically evaluated
2021-10-12 04:54:28 +02:00
let tmp = (mat.sllman[1] as string).replace(/MAX/g, (maxSell + "").toUpperCase());
2021-09-05 01:09:30 +02:00
tmp = tmp.replace(/PROD/g, mat.prd + "");
try {
sellAmt = eval(tmp);
} catch (e) {
dialogBoxCreate(
"Error evaluating your sell amount for material " +
mat.name +
" in " +
this.name +
"'s " +
city +
" office. The sell amount " +
"is being set to zero",
);
2021-08-31 08:49:57 +02:00
sellAmt = 0;
2021-09-05 01:09:30 +02:00
}
sellAmt = Math.min(maxSell, sellAmt);
} else if (mat.sllman[1] === -1) {
//Backwards compatibility, -1 = MAX
sellAmt = maxSell;
2021-08-31 08:49:57 +02:00
} else {
2021-09-05 01:09:30 +02:00
//Player's input value is just a number
sellAmt = Math.min(maxSell, mat.sllman[1] as number);
}
2021-09-09 05:47:34 +02:00
sellAmt = sellAmt * CorporationConstants.SecsPerMarketCycle * marketCycles;
2021-09-05 01:09:30 +02:00
sellAmt = Math.min(mat.qty, sellAmt);
if (sellAmt < 0) {
2021-09-09 05:47:34 +02:00
console.warn(`sellAmt calculated to be negative for ${matName} in ${city}`);
2021-09-05 01:09:30 +02:00
mat.sll = 0;
continue;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
if (sellAmt && sCost >= 0) {
mat.qty -= sellAmt;
revenue += sellAmt * sCost;
2021-09-09 05:47:34 +02:00
mat.sll = sellAmt / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-08-31 08:49:57 +02:00
} else {
2021-09-05 01:09:30 +02:00
mat.sll = 0;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
} //End processing of sale of materials
break;
case "EXPORT":
2022-01-16 01:45:03 +01:00
for (const matName of Object.keys(warehouse.materials)) {
2021-09-05 01:09:30 +02:00
if (warehouse.materials.hasOwnProperty(matName)) {
const mat = warehouse.materials[matName];
mat.totalExp = 0; //Reset export
for (let expI = 0; expI < mat.exp.length; ++expI) {
const exp = mat.exp[expI];
const amtStr = exp.amt.replace(
/MAX/g,
2021-10-12 04:54:28 +02:00
(mat.qty / (CorporationConstants.SecsPerMarketCycle * marketCycles) + "").toUpperCase(),
2021-09-05 01:09:30 +02:00
);
let amt = 0;
try {
amt = eval(amtStr);
} catch (e) {
dialogBoxCreate(
"Calculating export for " +
mat.name +
" in " +
this.name +
"'s " +
city +
" division failed with " +
"error: " +
e,
);
continue;
}
if (isNaN(amt)) {
dialogBoxCreate(
"Error calculating export amount for " +
mat.name +
" in " +
this.name +
"'s " +
city +
" division.",
);
continue;
}
2021-09-09 05:47:34 +02:00
amt = amt * CorporationConstants.SecsPerMarketCycle * marketCycles;
2021-09-05 01:09:30 +02:00
if (mat.qty < amt) {
amt = mat.qty;
}
if (amt === 0) {
break; //None left
}
for (let foo = 0; foo < corporation.divisions.length; ++foo) {
if (corporation.divisions[foo].name === exp.ind) {
const expIndustry = corporation.divisions[foo];
const expWarehouse = expIndustry.warehouses[exp.city];
if (!(expWarehouse instanceof Warehouse)) {
2021-09-09 05:47:34 +02:00
console.error(`Invalid export! ${expIndustry.name} ${exp.city}`);
2021-09-05 01:09:30 +02:00
break;
}
// Make sure theres enough space in warehouse
if (expWarehouse.sizeUsed >= expWarehouse.size) {
// Warehouse at capacity. Exporting doesnt
// affect revenue so just return 0's
return [0, 0];
} else {
2021-09-09 05:47:34 +02:00
const maxAmt = Math.floor((expWarehouse.size - expWarehouse.sizeUsed) / MaterialSizes[matName]);
2021-09-05 01:09:30 +02:00
amt = Math.min(maxAmt, amt);
}
expWarehouse.materials[matName].imp +=
2021-09-09 05:47:34 +02:00
amt / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-09-05 01:09:30 +02:00
expWarehouse.materials[matName].qty += amt;
expWarehouse.materials[matName].qlt = mat.qlt;
mat.qty -= amt;
mat.totalExp += amt;
expIndustry.updateWarehouseSizeUsed(expWarehouse);
break;
}
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
//totalExp should be per second
2021-09-09 05:47:34 +02:00
mat.totalExp /= CorporationConstants.SecsPerMarketCycle * marketCycles;
2021-09-05 01:09:30 +02:00
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
break;
case "START":
break;
default:
console.error(`Invalid state: ${this.state}`);
break;
} //End switch(this.state)
this.updateWarehouseSizeUsed(warehouse);
} // End warehouse
//Produce Scientific Research based on R&D employees
//Scientific Research can be produced without a warehouse
if (office instanceof OfficeSpace) {
this.sciResearch.qty +=
0.004 *
Math.pow(office.employeeProd[EmployeePositions.RandD], 0.5) *
corporation.getScientificResearchMultiplier() *
this.getScientificResearchMultiplier();
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
return [revenue, expenses];
}
//Process production & sale of this industry's FINISHED products (including all of their stats)
2021-09-09 05:47:34 +02:00
processProducts(marketCycles = 1, corporation: ICorporation): [number, number] {
2021-09-05 01:09:30 +02:00
let revenue = 0;
const expenses = 0;
//Create products
if (this.state === "PRODUCTION") {
2022-01-16 01:45:03 +01:00
for (const prodName of Object.keys(this.products)) {
2021-09-05 01:09:30 +02:00
const prod = this.products[prodName];
if (prod === undefined) continue;
if (!prod.fin) {
const city = prod.createCity;
const office = this.offices[city];
if (office === 0) continue;
// Designing/Creating a Product is based mostly off Engineers
const engrProd = office.employeeProd[EmployeePositions.Engineer];
const mgmtProd = office.employeeProd[EmployeePositions.Management];
const opProd = office.employeeProd[EmployeePositions.Operations];
const total = engrProd + mgmtProd + opProd;
if (total <= 0) {
break;
}
// Management is a multiplier for the production from Engineers
const mgmtFactor = 1 + mgmtProd / (1.2 * total);
2021-09-09 05:47:34 +02:00
const progress = (Math.pow(engrProd, 0.34) + Math.pow(opProd, 0.2)) * mgmtFactor;
2021-09-05 01:09:30 +02:00
prod.createProduct(marketCycles, progress);
if (prod.prog >= 100) {
prod.finishProduct(office.employeeProd, this);
}
break;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
//Produce Products
2022-01-16 01:45:03 +01:00
for (const prodName of Object.keys(this.products)) {
2021-09-05 01:09:30 +02:00
if (this.products.hasOwnProperty(prodName)) {
const prod = this.products[prodName];
if (prod instanceof Product && prod.fin) {
revenue += this.processProduct(marketCycles, prod, corporation);
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
return [revenue, expenses];
}
//Processes FINISHED products
2021-09-09 05:47:34 +02:00
processProduct(marketCycles = 1, product: Product, corporation: ICorporation): number {
2021-09-05 01:09:30 +02:00
let totalProfit = 0;
for (let i = 0; i < CorporationConstants.Cities.length; ++i) {
const city = CorporationConstants.Cities[i];
const office = this.offices[city];
if (office === 0) continue;
const warehouse = this.warehouses[city];
if (warehouse instanceof Warehouse) {
switch (this.state) {
case "PRODUCTION": {
//Calculate the maximum production of this material based
//on the office's productivity
const maxProd =
this.getOfficeProductivity(office, { forProduct: true }) *
corporation.getProductionMultiplier() *
this.prodMult * // Multiplier from materials
this.getProductionMultiplier() * // Multiplier from research
this.getProductProductionMultiplier(); // Multiplier from research
let prod;
//Account for whether production is manually limited
if (product.prdman[city][0]) {
prod = Math.min(maxProd, product.prdman[city][1]);
} else {
prod = maxProd;
}
prod *= CorporationConstants.SecsPerMarketCycle * marketCycles;
//Calculate net change in warehouse storage making the Products will cost
let netStorageSize = product.siz;
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(product.reqMats)) {
2021-09-05 01:09:30 +02:00
if (product.reqMats.hasOwnProperty(reqMatName)) {
const normQty = product.reqMats[reqMatName];
netStorageSize -= MaterialSizes[reqMatName] * normQty;
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
//If there's not enough space in warehouse, limit the amount of Product
if (netStorageSize > 0) {
2021-09-09 05:47:34 +02:00
const maxAmt = Math.floor((warehouse.size - warehouse.sizeUsed) / netStorageSize);
2021-09-05 01:09:30 +02:00
prod = Math.min(maxAmt, prod);
}
2021-08-31 08:49:57 +02:00
2021-09-09 05:47:34 +02:00
warehouse.smartSupplyStore += prod / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-09-05 01:09:30 +02:00
//Make sure we have enough resources to make our Products
let producableFrac = 1;
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(product.reqMats)) {
2021-09-05 01:09:30 +02:00
if (product.reqMats.hasOwnProperty(reqMatName)) {
const req = product.reqMats[reqMatName] * prod;
if (warehouse.materials[reqMatName].qty < req) {
2021-09-09 05:47:34 +02:00
producableFrac = Math.min(producableFrac, warehouse.materials[reqMatName].qty / req);
2021-09-05 01:09:30 +02:00
}
}
}
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
//Make our Products if they are producable
if (producableFrac > 0 && prod > 0) {
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(product.reqMats)) {
2021-09-05 01:09:30 +02:00
if (product.reqMats.hasOwnProperty(reqMatName)) {
2021-09-09 05:47:34 +02:00
const reqMatQtyNeeded = product.reqMats[reqMatName] * prod * producableFrac;
2021-09-05 01:09:30 +02:00
warehouse.materials[reqMatName].qty -= reqMatQtyNeeded;
warehouse.materials[reqMatName].prd -=
2021-09-09 05:47:34 +02:00
reqMatQtyNeeded / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-09-05 01:09:30 +02:00
}
}
//Quantity
product.data[city][0] += prod * producableFrac;
}
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
//Keep track of production Per second
2021-09-09 05:47:34 +02:00
product.data[city][1] = (prod * producableFrac) / (CorporationConstants.SecsPerMarketCycle * marketCycles);
2021-09-05 01:09:30 +02:00
break;
}
case "SALE": {
//Process sale of Products
product.pCost = 0; //Estimated production cost
2022-01-16 01:45:03 +01:00
for (const reqMatName of Object.keys(product.reqMats)) {
2021-09-05 01:09:30 +02:00
if (product.reqMats.hasOwnProperty(reqMatName)) {
2021-09-09 05:47:34 +02:00
product.pCost += product.reqMats[reqMatName] * warehouse.materials[reqMatName].bCost;
2021-09-05 01:09:30 +02:00
}
}
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
// Since its a product, its production cost is increased for labor
product.pCost *= CorporationConstants.ProductProductionCostRatio;
// Sale multipliers
const businessFactor = this.getBusinessFactor(office); //Business employee productivity
const advertisingFactor = this.getAdvertisingFactors()[0]; //Awareness + popularity
const marketFactor = this.getMarketFactor(product); //Competition + demand
// Calculate Sale Cost (sCost), which could be dynamically evaluated
const markupLimit = product.rat / product.mku;
let sCost;
if (product.marketTa2) {
const prod = product.data[city][1];
// Reverse engineer the 'maxSell' formula
// 1. Set 'maxSell' = prod
// 2. Substitute formula for 'markup'
// 3. Solve for 'sCost'roduct.pCost = sCost
const numerator = markupLimit;
const sqrtNumerator = prod;
const sqrtDenominator =
0.5 *
Math.pow(product.rat, 0.65) *
marketFactor *
corporation.getSalesMultiplier() *
businessFactor *
advertisingFactor *
this.getSalesMultiplier();
const denominator = Math.sqrt(sqrtNumerator / sqrtDenominator);
let optimalPrice;
if (sqrtDenominator === 0 || denominator === 0) {
if (sqrtNumerator === 0) {
optimalPrice = 0; // No production
} else {
optimalPrice = product.pCost + markupLimit;
2021-09-09 05:47:34 +02:00
console.warn(`In Corporation, found illegal 0s when trying to calculate MarketTA2 sale cost`);
2021-09-05 01:09:30 +02:00
}
} else {
optimalPrice = numerator / denominator + product.pCost;
}
// Store this "optimal Price" in a property so we don't have to re-calculate for UI
product.marketTa2Price[city] = optimalPrice;
sCost = optimalPrice;
} else if (product.marketTa1) {
sCost = product.pCost + markupLimit;
} else if (isString(product.sCost)) {
const sCostString = product.sCost as string;
if (product.mku === 0) {
console.error(`mku is zero, reverting to 1 to avoid Infinity`);
product.mku = 1;
}
2021-09-09 05:47:34 +02:00
sCost = sCostString.replace(/MP/g, product.pCost + product.rat / product.mku + "");
2021-09-05 01:09:30 +02:00
sCost = eval(sCost);
} else {
sCost = product.sCost;
}
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
let markup = 1;
if (sCost > product.pCost) {
if (sCost - product.pCost > markupLimit) {
markup = markupLimit / (sCost - product.pCost);
}
}
2021-08-31 08:49:57 +02:00
2021-09-05 01:09:30 +02:00
const maxSell =
0.5 *
Math.pow(product.rat, 0.65) *
marketFactor *
corporation.getSalesMultiplier() *
Math.pow(markup, 2) *
businessFactor *
advertisingFactor *
this.getSalesMultiplier();
let sellAmt;
if (product.sllman[city][0] && isString(product.sllman[city][1])) {
//Sell amount is dynamically evaluated
2021-10-12 04:54:28 +02:00
let tmp = product.sllman[city][1].replace(/MAX/g, (maxSell + "").toUpperCase());
2021-09-05 01:09:30 +02:00
tmp = tmp.replace(/PROD/g, product.data[city][1]);
try {
tmp = eval(tmp);
} catch (e) {
dialogBoxCreate(
"Error evaluating your sell price expression for " +
product.name +
" in " +
this.name +
"'s " +
city +
" office. Sell price is being set to MAX",
);
tmp = maxSell;
}
sellAmt = Math.min(maxSell, tmp);
} else if (product.sllman[city][0] && product.sllman[city][1] > 0) {
//Sell amount is manually limited
sellAmt = Math.min(maxSell, product.sllman[city][1]);
} else if (product.sllman[city][0] === false) {
sellAmt = 0;
} else {
sellAmt = maxSell;
}
if (sellAmt < 0) {
sellAmt = 0;
}
2021-09-09 05:47:34 +02:00
sellAmt = sellAmt * CorporationConstants.SecsPerMarketCycle * marketCycles;
2021-09-05 01:09:30 +02:00
sellAmt = Math.min(product.data[city][0], sellAmt); //data[0] is qty
if (sellAmt && sCost) {
product.data[city][0] -= sellAmt; //data[0] is qty
totalProfit += sellAmt * sCost;
2021-09-09 05:47:34 +02:00
product.data[city][2] = sellAmt / (CorporationConstants.SecsPerMarketCycle * marketCycles); //data[2] is sell property
2021-09-05 01:09:30 +02:00
} else {
product.data[city][2] = 0; //data[2] is sell property
}
break;
}
case "START":
case "PURCHASE":
case "EXPORT":
break;
default:
console.error(`Invalid State: ${this.state}`);
break;
} //End switch(this.state)
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
return totalProfit;
}
discontinueProduct(product: Product): void {
2022-01-16 01:45:03 +01:00
for (const productName of Object.keys(this.products)) {
2021-09-05 01:09:30 +02:00
if (this.products.hasOwnProperty(productName)) {
if (product === this.products[productName]) {
delete this.products[productName];
}
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
2021-09-09 05:47:34 +02:00
upgrade(upgrade: IndustryUpgrade, refs: { corporation: ICorporation; office: OfficeSpace }): void {
2021-09-05 01:09:30 +02:00
const corporation = refs.corporation;
const office = refs.office;
const upgN = upgrade[0];
while (this.upgrades.length <= upgN) {
this.upgrades.push(0);
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
++this.upgrades[upgN];
switch (upgN) {
case 0: {
//Coffee, 5% energy per employee
for (let i = 0; i < office.employees.length; ++i) {
2021-09-09 05:47:34 +02:00
office.employees[i].ene = Math.min(office.employees[i].ene * 1.05, office.maxEne);
2021-09-05 01:09:30 +02:00
}
break;
}
case 1: {
//AdVert.Inc,
2021-09-09 05:47:34 +02:00
const advMult = corporation.getAdvertisingMultiplier() * this.getAdvertisingMultiplier();
2022-01-14 11:05:00 +01:00
const awareness = (this.awareness + (3 * advMult)) * (1.01 * advMult);
this.awareness = Math.min(awareness, Number.MAX_VALUE);
2022-01-14 11:05:00 +01:00
const popularity = (this.popularity + (1 * advMult)) * ((1 + getRandomInt(1, 3) / 100) * advMult);
this.popularity = Math.min(popularity, Number.MAX_VALUE);
2021-09-05 01:09:30 +02:00
break;
}
default: {
console.error(`Un-implemented function index: ${upgN}`);
break;
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
// Returns how much of a material can be produced based of office productivity (employee stats)
2021-09-09 05:47:34 +02:00
getOfficeProductivity(office: OfficeSpace, params: { forProduct?: boolean } = {}): number {
2021-09-05 01:09:30 +02:00
const opProd = office.employeeProd[EmployeePositions.Operations];
const engrProd = office.employeeProd[EmployeePositions.Engineer];
const mgmtProd = office.employeeProd[EmployeePositions.Management];
const total = opProd + engrProd + mgmtProd;
if (total <= 0) return 0;
// Management is a multiplier for the production from Operations and Engineers
const mgmtFactor = 1 + mgmtProd / (1.2 * total);
// For production, Operations is slightly more important than engineering
// Both Engineering and Operations have diminishing returns
const prod = (Math.pow(opProd, 0.4) + Math.pow(engrProd, 0.3)) * mgmtFactor;
// Generic multiplier for the production. Used for game-balancing purposes
const balancingMult = 0.05;
if (params && params.forProduct) {
// Products are harder to create and therefore have less production
return 0.5 * balancingMult * prod;
} else {
return balancingMult * prod;
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
// Returns a multiplier based on the office' 'Business' employees that affects sales
getBusinessFactor(office: OfficeSpace): number {
const businessProd = 1 + office.employeeProd[EmployeePositions.Business];
return calculateEffectWithFactors(businessProd, 0.26, 10e3);
}
//Returns a set of multipliers based on the Industry's awareness, popularity, and advFac. This
//multiplier affects sales. The result is:
// [Total sales mult, total awareness mult, total pop mult, awareness/pop ratio mult]
getAdvertisingFactors(): [number, number, number, number] {
const awarenessFac = Math.pow(this.awareness + 1, this.advFac);
const popularityFac = Math.pow(this.popularity + 1, this.advFac);
2021-09-09 05:47:34 +02:00
const ratioFac = this.awareness === 0 ? 0.01 : Math.max((this.popularity + 0.001) / this.awareness, 0.01);
2021-09-05 01:09:30 +02:00
const totalFac = Math.pow(awarenessFac * popularityFac * ratioFac, 0.85);
return [totalFac, awarenessFac, popularityFac, ratioFac];
}
//Returns a multiplier based on a materials demand and competition that affects sales
getMarketFactor(mat: { dmd: number; cmp: number }): number {
return Math.max(0.1, (mat.dmd * (100 - mat.cmp)) / 100);
}
// Returns a boolean indicating whether this Industry has the specified Research
hasResearch(name: string): boolean {
return this.researched[name] === true;
}
updateResearchTree(): void {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry "${this.type}"`);
2021-09-05 01:09:30 +02:00
// Since ResearchTree data isnt saved, we'll update the Research Tree data
// based on the stored 'researched' property in the Industry object
2021-09-09 05:47:34 +02:00
if (Object.keys(researchTree.researched).length !== Object.keys(this.researched).length) {
2022-01-16 01:45:03 +01:00
for (const research of Object.keys(this.researched)) {
2021-09-05 01:09:30 +02:00
researchTree.research(research);
}
2021-08-31 08:49:57 +02:00
}
2021-09-05 01:09:30 +02:00
}
// Get multipliers from Research
getAdvertisingMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getAdvertisingMultiplier();
}
getEmployeeChaMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getEmployeeChaMultiplier();
}
getEmployeeCreMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getEmployeeCreMultiplier();
}
getEmployeeEffMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getEmployeeEffMultiplier();
}
getEmployeeIntMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getEmployeeIntMultiplier();
}
getProductionMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getProductionMultiplier();
}
getProductProductionMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getProductProductionMultiplier();
}
getSalesMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getSalesMultiplier();
}
getScientificResearchMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getScientificResearchMultiplier();
}
getStorageMultiplier(): number {
const researchTree = IndustryResearchTrees[this.type];
2021-09-09 05:47:34 +02:00
if (researchTree === undefined) throw new Error(`Invalid industry: "${this.type}"`);
2021-09-05 01:09:30 +02:00
this.updateResearchTree();
return researchTree.getStorageMultiplier();
}
/**
* Serialize the current object to a JSON save state.
*/
toJSON(): any {
return Generic_toJSON("Industry", this);
}
/**
* Initiatizes a Industry object from a JSON save state.
*/
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
static fromJSON(value: any): Industry {
return Generic_fromJSON(Industry, value.data);
}
2021-08-31 08:49:57 +02:00
}
Reviver.constructors.Industry = Industry;