mirror of
https://github.com/bitburner-official/bitburner-src.git
synced 2024-11-11 18:23:54 +01:00
347 lines
12 KiB
TypeScript
347 lines
12 KiB
TypeScript
import { GangMemberTask } from "./GangMemberTask";
|
|
import { GangMemberTasks } from "./GangMemberTasks";
|
|
import { GangMemberUpgrade } from "./GangMemberUpgrade";
|
|
import { GangMemberUpgrades } from "./GangMemberUpgrades";
|
|
import { IAscensionResult } from "./IAscensionResult";
|
|
import { IPlayer } from "../PersonObjects/IPlayer";
|
|
import { AllGangs } from "./AllGangs";
|
|
import { IGang } from "./IGang";
|
|
import { Generic_fromJSON, Generic_toJSON, Reviver } from "../utils/JSONReviver";
|
|
import { BitNodeMultipliers } from "../BitNode/BitNodeMultipliers";
|
|
|
|
interface IMults {
|
|
hack: number;
|
|
str: number;
|
|
def: number;
|
|
dex: number;
|
|
agi: number;
|
|
cha: number;
|
|
}
|
|
|
|
export class GangMember {
|
|
name: string;
|
|
task = "Unassigned";
|
|
|
|
earnedRespect = 0;
|
|
|
|
hack = 1;
|
|
str = 1;
|
|
def = 1;
|
|
dex = 1;
|
|
agi = 1;
|
|
cha = 1;
|
|
|
|
hack_exp = 0;
|
|
str_exp = 0;
|
|
def_exp = 0;
|
|
dex_exp = 0;
|
|
agi_exp = 0;
|
|
cha_exp = 0;
|
|
|
|
hack_mult = 1;
|
|
str_mult = 1;
|
|
def_mult = 1;
|
|
dex_mult = 1;
|
|
agi_mult = 1;
|
|
cha_mult = 1;
|
|
|
|
hack_asc_points = 0;
|
|
str_asc_points = 0;
|
|
def_asc_points = 0;
|
|
dex_asc_points = 0;
|
|
agi_asc_points = 0;
|
|
cha_asc_points = 0;
|
|
|
|
upgrades: string[] = []; // Names of upgrades
|
|
augmentations: string[] = []; // Names of augmentations only
|
|
|
|
constructor(name = "") {
|
|
this.name = name;
|
|
}
|
|
|
|
calculateSkill(exp: number, mult = 1): number {
|
|
return Math.max(Math.floor(mult * (32 * Math.log(exp + 534.5) - 200)), 1);
|
|
}
|
|
|
|
calculateAscensionMult(points: number): number {
|
|
return Math.max(Math.pow(points / 2000, 0.7), 1);
|
|
}
|
|
|
|
updateSkillLevels(): void {
|
|
this.hack = this.calculateSkill(this.hack_exp, this.hack_mult * this.calculateAscensionMult(this.hack_asc_points));
|
|
this.str = this.calculateSkill(this.str_exp, this.str_mult * this.calculateAscensionMult(this.str_asc_points));
|
|
this.def = this.calculateSkill(this.def_exp, this.def_mult * this.calculateAscensionMult(this.def_asc_points));
|
|
this.dex = this.calculateSkill(this.dex_exp, this.dex_mult * this.calculateAscensionMult(this.dex_asc_points));
|
|
this.agi = this.calculateSkill(this.agi_exp, this.agi_mult * this.calculateAscensionMult(this.agi_asc_points));
|
|
this.cha = this.calculateSkill(this.cha_exp, this.cha_mult * this.calculateAscensionMult(this.cha_asc_points));
|
|
}
|
|
|
|
calculatePower(): number {
|
|
return (this.hack + this.str + this.def + this.dex + this.agi + this.cha) / 95;
|
|
}
|
|
|
|
assignToTask(taskName: string): boolean {
|
|
if (!GangMemberTasks.hasOwnProperty(taskName)) {
|
|
this.task = "Unassigned";
|
|
return false;
|
|
}
|
|
this.task = taskName;
|
|
return true;
|
|
}
|
|
|
|
unassignFromTask(): void {
|
|
this.task = "Unassigned";
|
|
}
|
|
|
|
getTask(): GangMemberTask {
|
|
// TODO(hydroflame): transfer that to a save file migration function
|
|
// Backwards compatibility
|
|
if ((this.task as any) instanceof GangMemberTask) {
|
|
this.task = (this.task as any).name;
|
|
}
|
|
|
|
if (GangMemberTasks.hasOwnProperty(this.task)) {
|
|
return GangMemberTasks[this.task];
|
|
}
|
|
return GangMemberTasks["Unassigned"];
|
|
}
|
|
|
|
calculateRespectGain(gang: IGang): number {
|
|
const task = this.getTask();
|
|
if (task.baseRespect === 0) return 0;
|
|
let statWeight =
|
|
(task.hackWeight / 100) * this.hack +
|
|
(task.strWeight / 100) * this.str +
|
|
(task.defWeight / 100) * this.def +
|
|
(task.dexWeight / 100) * this.dex +
|
|
(task.agiWeight / 100) * this.agi +
|
|
(task.chaWeight / 100) * this.cha;
|
|
statWeight -= 4 * task.difficulty;
|
|
if (statWeight <= 0) return 0;
|
|
const territoryMult = Math.max(
|
|
0.005,
|
|
Math.pow(AllGangs[gang.facName].territory * 100, task.territory.respect) / 100,
|
|
);
|
|
const territoryPenalty = (0.2 * gang.getTerritory() + 0.8) * BitNodeMultipliers.GangSoftcap;
|
|
if (isNaN(territoryMult) || territoryMult <= 0) return 0;
|
|
const respectMult = gang.getWantedPenalty();
|
|
return Math.pow(11 * task.baseRespect * statWeight * territoryMult * respectMult, territoryPenalty);
|
|
}
|
|
|
|
calculateWantedLevelGain(gang: IGang): number {
|
|
const task = this.getTask();
|
|
if (task.baseWanted === 0) return 0;
|
|
let statWeight =
|
|
(task.hackWeight / 100) * this.hack +
|
|
(task.strWeight / 100) * this.str +
|
|
(task.defWeight / 100) * this.def +
|
|
(task.dexWeight / 100) * this.dex +
|
|
(task.agiWeight / 100) * this.agi +
|
|
(task.chaWeight / 100) * this.cha;
|
|
statWeight -= 3.5 * task.difficulty;
|
|
if (statWeight <= 0) return 0;
|
|
const territoryMult = Math.max(
|
|
0.005,
|
|
Math.pow(AllGangs[gang.facName].territory * 100, task.territory.wanted) / 100,
|
|
);
|
|
if (isNaN(territoryMult) || territoryMult <= 0) return 0;
|
|
if (task.baseWanted < 0) {
|
|
return 0.4 * task.baseWanted * statWeight * territoryMult;
|
|
}
|
|
const calc = (7 * task.baseWanted) / Math.pow(3 * statWeight * territoryMult, 0.8);
|
|
|
|
// Put an arbitrary cap on this to prevent wanted level from rising too fast if the
|
|
// denominator is very small. Might want to rethink formula later
|
|
return Math.min(100, calc);
|
|
}
|
|
|
|
calculateMoneyGain(gang: IGang): number {
|
|
const task = this.getTask();
|
|
if (task.baseMoney === 0) return 0;
|
|
let statWeight =
|
|
(task.hackWeight / 100) * this.hack +
|
|
(task.strWeight / 100) * this.str +
|
|
(task.defWeight / 100) * this.def +
|
|
(task.dexWeight / 100) * this.dex +
|
|
(task.agiWeight / 100) * this.agi +
|
|
(task.chaWeight / 100) * this.cha;
|
|
|
|
statWeight -= 3.2 * task.difficulty;
|
|
if (statWeight <= 0) return 0;
|
|
const territoryMult = Math.max(0.005, Math.pow(AllGangs[gang.facName].territory * 100, task.territory.money) / 100);
|
|
if (isNaN(territoryMult) || territoryMult <= 0) return 0;
|
|
const respectMult = gang.getWantedPenalty();
|
|
const territoryPenalty = (0.2 * gang.getTerritory() + 0.8) * BitNodeMultipliers.GangSoftcap;
|
|
return Math.pow(5 * task.baseMoney * statWeight * territoryMult * respectMult, territoryPenalty);
|
|
}
|
|
|
|
expMult(): IMults {
|
|
return {
|
|
hack: (this.hack_mult - 1) / 4 + 1,
|
|
str: (this.str_mult - 1) / 4 + 1,
|
|
def: (this.def_mult - 1) / 4 + 1,
|
|
dex: (this.dex_mult - 1) / 4 + 1,
|
|
agi: (this.agi_mult - 1) / 4 + 1,
|
|
cha: (this.cha_mult - 1) / 4 + 1,
|
|
};
|
|
}
|
|
|
|
gainExperience(numCycles = 1): void {
|
|
const task = this.getTask();
|
|
if (task === GangMemberTasks["Unassigned"]) return;
|
|
const difficultyMult = Math.pow(task.difficulty, 0.9);
|
|
const difficultyPerCycles = difficultyMult * numCycles;
|
|
const weightDivisor = 1500;
|
|
const expMult = this.expMult();
|
|
this.hack_exp += (task.hackWeight / weightDivisor) * difficultyPerCycles * expMult.hack;
|
|
this.str_exp += (task.strWeight / weightDivisor) * difficultyPerCycles * expMult.str;
|
|
this.def_exp += (task.defWeight / weightDivisor) * difficultyPerCycles * expMult.def;
|
|
this.dex_exp += (task.dexWeight / weightDivisor) * difficultyPerCycles * expMult.dex;
|
|
this.agi_exp += (task.agiWeight / weightDivisor) * difficultyPerCycles * expMult.agi;
|
|
this.cha_exp += (task.chaWeight / weightDivisor) * difficultyPerCycles * expMult.cha;
|
|
}
|
|
|
|
recordEarnedRespect(numCycles = 1, gang: IGang): void {
|
|
this.earnedRespect += this.calculateRespectGain(gang) * numCycles;
|
|
}
|
|
|
|
getGainedAscensionPoints(): IMults {
|
|
return {
|
|
hack: Math.max(this.hack_exp - 1000, 0),
|
|
str: Math.max(this.str_exp - 1000, 0),
|
|
def: Math.max(this.def_exp - 1000, 0),
|
|
dex: Math.max(this.dex_exp - 1000, 0),
|
|
agi: Math.max(this.agi_exp - 1000, 0),
|
|
cha: Math.max(this.cha_exp - 1000, 0),
|
|
};
|
|
}
|
|
|
|
canAscend(): boolean {
|
|
const points = this.getGainedAscensionPoints();
|
|
return points.hack > 0 || points.str > 0 || points.def > 0 || points.dex > 0 || points.agi > 0 || points.cha > 0;
|
|
}
|
|
|
|
getCurrentAscensionMults(): IMults {
|
|
return {
|
|
hack: this.calculateAscensionMult(this.hack_asc_points),
|
|
str: this.calculateAscensionMult(this.str_asc_points),
|
|
def: this.calculateAscensionMult(this.def_asc_points),
|
|
dex: this.calculateAscensionMult(this.dex_asc_points),
|
|
agi: this.calculateAscensionMult(this.agi_asc_points),
|
|
cha: this.calculateAscensionMult(this.cha_asc_points),
|
|
};
|
|
}
|
|
|
|
getAscensionMultsAfterAscend(): IMults {
|
|
const points = this.getGainedAscensionPoints();
|
|
return {
|
|
hack: this.calculateAscensionMult(this.hack_asc_points + points.hack),
|
|
str: this.calculateAscensionMult(this.str_asc_points + points.str),
|
|
def: this.calculateAscensionMult(this.def_asc_points + points.def),
|
|
dex: this.calculateAscensionMult(this.dex_asc_points + points.dex),
|
|
agi: this.calculateAscensionMult(this.agi_asc_points + points.agi),
|
|
cha: this.calculateAscensionMult(this.cha_asc_points + points.cha),
|
|
};
|
|
}
|
|
|
|
getAscensionResults(): IMults {
|
|
const postAscend = this.getAscensionMultsAfterAscend();
|
|
const preAscend = this.getCurrentAscensionMults();
|
|
|
|
return {
|
|
hack: postAscend.hack / preAscend.hack,
|
|
str: postAscend.str / preAscend.str,
|
|
def: postAscend.def / preAscend.def,
|
|
dex: postAscend.dex / preAscend.dex,
|
|
agi: postAscend.agi / preAscend.agi,
|
|
cha: postAscend.cha / preAscend.cha,
|
|
};
|
|
}
|
|
|
|
ascend(): IAscensionResult {
|
|
const res = this.getAscensionResults();
|
|
const points = this.getGainedAscensionPoints();
|
|
this.hack_asc_points += points.hack;
|
|
this.str_asc_points += points.str;
|
|
this.def_asc_points += points.def;
|
|
this.dex_asc_points += points.dex;
|
|
this.agi_asc_points += points.agi;
|
|
this.cha_asc_points += points.cha;
|
|
|
|
// Remove upgrades. Then re-calculate multipliers and stats
|
|
this.upgrades.length = 0;
|
|
this.hack_mult = 1;
|
|
this.str_mult = 1;
|
|
this.def_mult = 1;
|
|
this.dex_mult = 1;
|
|
this.agi_mult = 1;
|
|
this.cha_mult = 1;
|
|
for (let i = 0; i < this.augmentations.length; ++i) {
|
|
const aug = GangMemberUpgrades[this.augmentations[i]];
|
|
this.applyUpgrade(aug);
|
|
}
|
|
|
|
// Clear exp and recalculate stats
|
|
this.hack_exp = 0;
|
|
this.str_exp = 0;
|
|
this.def_exp = 0;
|
|
this.dex_exp = 0;
|
|
this.agi_exp = 0;
|
|
this.cha_exp = 0;
|
|
this.updateSkillLevels();
|
|
|
|
const respectToDeduct = this.earnedRespect;
|
|
this.earnedRespect = 0;
|
|
return {
|
|
respect: respectToDeduct,
|
|
hack: res.hack,
|
|
str: res.str,
|
|
def: res.def,
|
|
dex: res.dex,
|
|
agi: res.agi,
|
|
cha: res.cha,
|
|
};
|
|
}
|
|
|
|
applyUpgrade(upg: GangMemberUpgrade): void {
|
|
if (upg.mults.str != null) this.str_mult *= upg.mults.str;
|
|
if (upg.mults.def != null) this.def_mult *= upg.mults.def;
|
|
if (upg.mults.dex != null) this.dex_mult *= upg.mults.dex;
|
|
if (upg.mults.agi != null) this.agi_mult *= upg.mults.agi;
|
|
if (upg.mults.cha != null) this.cha_mult *= upg.mults.cha;
|
|
if (upg.mults.hack != null) this.hack_mult *= upg.mults.hack;
|
|
}
|
|
|
|
buyUpgrade(upg: GangMemberUpgrade, player: IPlayer, gang: IGang): boolean {
|
|
// Prevent purchasing of already-owned upgrades
|
|
if (this.augmentations.includes(upg.name) || this.upgrades.includes(upg.name)) return false;
|
|
|
|
if (player.money.lt(gang.getUpgradeCost(upg))) return false;
|
|
player.loseMoney(gang.getUpgradeCost(upg), "gang");
|
|
if (upg.type === "g") {
|
|
this.augmentations.push(upg.name);
|
|
} else {
|
|
this.upgrades.push(upg.name);
|
|
}
|
|
this.applyUpgrade(upg);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Serialize the current object to a JSON save state.
|
|
*/
|
|
toJSON(): any {
|
|
return Generic_toJSON("GangMember", this);
|
|
}
|
|
|
|
/**
|
|
* Initiatizes a GangMember object from a JSON save state.
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
|
|
static fromJSON(value: any): GangMember {
|
|
return Generic_fromJSON(GangMember, value.data);
|
|
}
|
|
}
|
|
|
|
Reviver.constructors.GangMember = GangMember;
|