645 lines
27 KiB
TypeScript
645 lines
27 KiB
TypeScript
import { HandbookHelper } from "@spt/helpers/HandbookHelper";
|
|
import { ItemHelper } from "@spt/helpers/ItemHelper";
|
|
import { PresetHelper } from "@spt/helpers/PresetHelper";
|
|
import { IItem } from "@spt/models/eft/common/tables/IItem";
|
|
import { IQuestReward, IQuestRewards } from "@spt/models/eft/common/tables/IQuest";
|
|
import { ITemplateItem } from "@spt/models/eft/common/tables/ITemplateItem";
|
|
import { BaseClasses } from "@spt/models/enums/BaseClasses";
|
|
import { ConfigTypes } from "@spt/models/enums/ConfigTypes";
|
|
import { Money } from "@spt/models/enums/Money";
|
|
import { QuestRewardType } from "@spt/models/enums/QuestRewardType";
|
|
import { Traders } from "@spt/models/enums/Traders";
|
|
import {
|
|
IBaseQuestConfig,
|
|
IQuestConfig,
|
|
IRepeatableQuestConfig,
|
|
IRewardScaling,
|
|
} from "@spt/models/spt/config/IQuestConfig";
|
|
import { IQuestRewardValues } from "@spt/models/spt/repeatable/IQuestRewardValues";
|
|
import { ExhaustableArray } from "@spt/models/spt/server/ExhaustableArray";
|
|
import { ILogger } from "@spt/models/spt/utils/ILogger";
|
|
import { ConfigServer } from "@spt/servers/ConfigServer";
|
|
import { DatabaseService } from "@spt/services/DatabaseService";
|
|
import { ItemFilterService } from "@spt/services/ItemFilterService";
|
|
import { LocalisationService } from "@spt/services/LocalisationService";
|
|
import { SeasonalEventService } from "@spt/services/SeasonalEventService";
|
|
import { MathUtil } from "@spt/utils/MathUtil";
|
|
import { ObjectId } from "@spt/utils/ObjectId";
|
|
import { RandomUtil } from "@spt/utils/RandomUtil";
|
|
import { ICloner } from "@spt/utils/cloners/ICloner";
|
|
import { inject, injectable } from "tsyringe";
|
|
|
|
@injectable()
|
|
export class RepeatableQuestRewardGenerator {
|
|
protected questConfig: IQuestConfig;
|
|
|
|
constructor(
|
|
@inject("PrimaryLogger") protected logger: ILogger,
|
|
@inject("RandomUtil") protected randomUtil: RandomUtil,
|
|
@inject("MathUtil") protected mathUtil: MathUtil,
|
|
@inject("DatabaseService") protected databaseService: DatabaseService,
|
|
@inject("ItemHelper") protected itemHelper: ItemHelper,
|
|
@inject("PresetHelper") protected presetHelper: PresetHelper,
|
|
@inject("HandbookHelper") protected handbookHelper: HandbookHelper,
|
|
@inject("LocalisationService") protected localisationService: LocalisationService,
|
|
@inject("ObjectId") protected objectId: ObjectId,
|
|
@inject("ItemFilterService") protected itemFilterService: ItemFilterService,
|
|
@inject("SeasonalEventService") protected seasonalEventService: SeasonalEventService,
|
|
@inject("ConfigServer") protected configServer: ConfigServer,
|
|
@inject("PrimaryCloner") protected cloner: ICloner,
|
|
) {
|
|
this.questConfig = this.configServer.getConfig(ConfigTypes.QUEST);
|
|
}
|
|
|
|
/**
|
|
* Generate the reward for a mission. A reward can consist of:
|
|
* - Experience
|
|
* - Money
|
|
* - GP coins
|
|
* - Weapon preset
|
|
* - Items
|
|
* - Trader Reputation
|
|
* - Skill level experience
|
|
*
|
|
* The reward is dependent on the player level as given by the wiki. The exact mapping of pmcLevel to
|
|
* experience / money / items / trader reputation can be defined in QuestConfig.js
|
|
*
|
|
* There's also a random variation of the reward the spread of which can be also defined in the config
|
|
*
|
|
* Additionally, a scaling factor w.r.t. quest difficulty going from 0.2...1 can be used
|
|
* @param pmcLevel Level of player reward is being generated for
|
|
* @param difficulty Reward scaling factor from 0.2 to 1
|
|
* @param traderId Trader reward will be given by
|
|
* @param repeatableConfig Config for quest type (daily, weekly)
|
|
* @param questConfig
|
|
* @param rewardTplBlacklist OPTIONAL: list of tpls to NOT use when picking a reward
|
|
* @returns IQuestRewards
|
|
*/
|
|
public generateReward(
|
|
pmcLevel: number,
|
|
difficulty: number,
|
|
traderId: string,
|
|
repeatableConfig: IRepeatableQuestConfig,
|
|
questConfig: IBaseQuestConfig,
|
|
rewardTplBlacklist?: string[],
|
|
): IQuestRewards {
|
|
// Get vars to configure rewards with
|
|
const rewardParams = this.getQuestRewardValues(repeatableConfig.rewardScaling, difficulty, pmcLevel);
|
|
|
|
// Get budget to spend on item rewards (copy of raw roubles given)
|
|
let itemRewardBudget = rewardParams.rewardRoubles;
|
|
|
|
// Possible improvement -> draw trader-specific items e.g. with this.itemHelper.isOfBaseclass(val._id, ItemHelper.BASECLASS.FoodDrink)
|
|
const rewards: IQuestRewards = { Started: [], Success: [], Fail: [] };
|
|
|
|
// Start reward index to keep track
|
|
let rewardIndex = 0;
|
|
|
|
// Add xp reward
|
|
if (rewardParams.rewardXP > 0) {
|
|
rewards.Success.push({
|
|
value: rewardParams.rewardXP,
|
|
type: QuestRewardType.EXPERIENCE,
|
|
index: rewardIndex,
|
|
});
|
|
rewardIndex++;
|
|
}
|
|
|
|
// Add money reward
|
|
rewards.Success.push(this.getMoneyReward(traderId, rewardParams.rewardRoubles, rewardIndex));
|
|
rewardIndex++;
|
|
|
|
// Add GP coin reward
|
|
rewards.Success.push(this.generateItemReward(Money.GP, rewardParams.gpCoinRewardCount, rewardIndex));
|
|
rewardIndex++;
|
|
|
|
// Add preset weapon to reward if checks pass
|
|
const traderWhitelistDetails = repeatableConfig.traderWhitelist.find(
|
|
(traderWhitelist) => traderWhitelist.traderId === traderId,
|
|
);
|
|
if (
|
|
traderWhitelistDetails?.rewardCanBeWeapon &&
|
|
this.randomUtil.getChance100(traderWhitelistDetails.weaponRewardChancePercent)
|
|
) {
|
|
const chosenWeapon = this.getRandomWeaponPresetWithinBudget(itemRewardBudget, rewardIndex);
|
|
if (chosenWeapon) {
|
|
rewards.Success.push(chosenWeapon.weapon);
|
|
|
|
// Subtract price of preset from item budget so we dont give player too much stuff
|
|
itemRewardBudget -= chosenWeapon.price;
|
|
rewardIndex++;
|
|
}
|
|
}
|
|
|
|
let inBudgetRewardItemPool = this.chooseRewardItemsWithinBudget(repeatableConfig, itemRewardBudget, traderId);
|
|
if (rewardTplBlacklist) {
|
|
// Filter reward pool of items from blacklist, only use if there's at least 1 item remaining
|
|
const filteredRewardItemPool = inBudgetRewardItemPool.filter((x) => !rewardTplBlacklist.includes(x._id));
|
|
if (filteredRewardItemPool.length > 0) {
|
|
inBudgetRewardItemPool = filteredRewardItemPool;
|
|
}
|
|
}
|
|
|
|
this.logger.debug(
|
|
`Generating daily quest for: ${traderId} with budget: ${itemRewardBudget} totalling: ${rewardParams.rewardNumItems} items`,
|
|
);
|
|
if (inBudgetRewardItemPool.length > 0) {
|
|
const itemsToReward = this.getRewardableItemsFromPoolWithinBudget(
|
|
inBudgetRewardItemPool,
|
|
rewardParams.rewardNumItems,
|
|
itemRewardBudget,
|
|
repeatableConfig,
|
|
);
|
|
|
|
// Add item rewards
|
|
for (const itemReward of itemsToReward) {
|
|
rewards.Success.push(this.generateItemReward(itemReward.item._id, itemReward.stackSize, rewardIndex));
|
|
rewardIndex++;
|
|
}
|
|
}
|
|
|
|
// Add rep reward to rewards array
|
|
if (rewardParams.rewardReputation > 0) {
|
|
const reward: IQuestReward = {
|
|
target: traderId,
|
|
value: rewardParams.rewardReputation,
|
|
type: QuestRewardType.TRADER_STANDING,
|
|
index: rewardIndex,
|
|
};
|
|
rewards.Success.push(reward);
|
|
rewardIndex++;
|
|
|
|
this.logger.debug(` Adding ${rewardParams.rewardReputation} trader reputation reward`);
|
|
}
|
|
|
|
// Chance of adding skill reward
|
|
if (this.randomUtil.getChance100(rewardParams.skillRewardChance * 100)) {
|
|
const targetSkill = this.randomUtil.getArrayValue(questConfig.possibleSkillRewards);
|
|
const reward: IQuestReward = {
|
|
target: targetSkill,
|
|
value: rewardParams.skillPointReward,
|
|
type: QuestRewardType.SKILL,
|
|
index: rewardIndex,
|
|
};
|
|
rewards.Success.push(reward);
|
|
|
|
this.logger.debug(` Adding ${rewardParams.skillPointReward} skill points to ${targetSkill}`);
|
|
}
|
|
|
|
return rewards;
|
|
}
|
|
|
|
protected getQuestRewardValues(
|
|
rewardScaling: IRewardScaling,
|
|
difficulty: number,
|
|
pmcLevel: number,
|
|
): IQuestRewardValues {
|
|
// difficulty could go from 0.2 ... -> for lowest difficulty receive 0.2*nominal reward
|
|
const levelsConfig = rewardScaling.levels;
|
|
const roublesConfig = rewardScaling.roubles;
|
|
const gpCoinConfig = rewardScaling.gpCoins;
|
|
const xpConfig = rewardScaling.experience;
|
|
const itemsConfig = rewardScaling.items;
|
|
const rewardSpreadConfig = rewardScaling.rewardSpread;
|
|
const skillRewardChanceConfig = rewardScaling.skillRewardChance;
|
|
const skillPointRewardConfig = rewardScaling.skillPointReward;
|
|
const reputationConfig = rewardScaling.reputation;
|
|
|
|
const effectiveDifficulty = Number.isNaN(difficulty) ? 1 : difficulty;
|
|
if (Number.isNaN(difficulty)) {
|
|
this.logger.warning(this.localisationService.getText("repeatable-difficulty_was_nan"));
|
|
}
|
|
|
|
return {
|
|
skillPointReward: this.mathUtil.interp1(pmcLevel, levelsConfig, skillPointRewardConfig),
|
|
skillRewardChance: this.mathUtil.interp1(pmcLevel, levelsConfig, skillRewardChanceConfig),
|
|
rewardReputation:
|
|
Math.round(
|
|
100 *
|
|
effectiveDifficulty *
|
|
this.mathUtil.interp1(pmcLevel, levelsConfig, reputationConfig) *
|
|
this.randomUtil.getFloat(1 - rewardSpreadConfig, 1 + rewardSpreadConfig),
|
|
) / 100,
|
|
rewardNumItems: this.randomUtil.randInt(
|
|
1,
|
|
Math.round(this.mathUtil.interp1(pmcLevel, levelsConfig, itemsConfig)) + 1,
|
|
),
|
|
rewardRoubles: Math.floor(
|
|
effectiveDifficulty *
|
|
this.mathUtil.interp1(pmcLevel, levelsConfig, roublesConfig) *
|
|
this.randomUtil.getFloat(1 - rewardSpreadConfig, 1 + rewardSpreadConfig),
|
|
),
|
|
gpCoinRewardCount: Math.ceil(
|
|
// Ceil value to ensure it never drops below 1
|
|
effectiveDifficulty *
|
|
this.mathUtil.interp1(pmcLevel, levelsConfig, gpCoinConfig) *
|
|
this.randomUtil.getFloat(1 - rewardSpreadConfig, 1 + rewardSpreadConfig),
|
|
),
|
|
rewardXP: Math.floor(
|
|
effectiveDifficulty *
|
|
this.mathUtil.interp1(pmcLevel, levelsConfig, xpConfig) *
|
|
this.randomUtil.getFloat(1 - rewardSpreadConfig, 1 + rewardSpreadConfig),
|
|
),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get an array of items + stack size to give to player as reward that fit inside of a rouble budget
|
|
* @param itemPool All possible items to choose rewards from
|
|
* @param maxItemCount Total number of items to reward
|
|
* @param itemRewardBudget Rouble buget all item rewards must fit in
|
|
* @param repeatableConfig config for quest type
|
|
* @returns Items and stack size
|
|
*/
|
|
protected getRewardableItemsFromPoolWithinBudget(
|
|
itemPool: ITemplateItem[],
|
|
maxItemCount: number,
|
|
itemRewardBudget: number,
|
|
repeatableConfig: IRepeatableQuestConfig,
|
|
): { item: ITemplateItem; stackSize: number }[] {
|
|
const itemsToReturn: { item: ITemplateItem; stackSize: number }[] = [];
|
|
let exhausableItemPool = new ExhaustableArray(itemPool, this.randomUtil, this.cloner);
|
|
|
|
for (let i = 0; i < maxItemCount; i++) {
|
|
// Default stack size to 1
|
|
let rewardItemStackCount = 1;
|
|
|
|
// Get a random item
|
|
const chosenItemFromPool = exhausableItemPool.getRandomValue();
|
|
if (!exhausableItemPool.hasValues()) {
|
|
break;
|
|
}
|
|
|
|
// Handle edge case - ammo
|
|
if (this.itemHelper.isOfBaseclass(chosenItemFromPool._id, BaseClasses.AMMO)) {
|
|
// Don't reward ammo that stacks to less than what's allowed in config
|
|
if (chosenItemFromPool._props.StackMaxSize < repeatableConfig.rewardAmmoStackMinSize) {
|
|
i--;
|
|
continue;
|
|
}
|
|
|
|
// Choose smallest value between budget, fitting size and stack max
|
|
rewardItemStackCount = this.calculateAmmoStackSizeThatFitsBudget(
|
|
chosenItemFromPool,
|
|
itemRewardBudget,
|
|
maxItemCount,
|
|
);
|
|
}
|
|
|
|
// 25% chance to double, triple or quadruple reward stack
|
|
// (Only occurs when item is stackable and not weapon, armor or ammo)
|
|
if (this.canIncreaseRewardItemStackSize(chosenItemFromPool, 70000, 25)) {
|
|
rewardItemStackCount = this.getRandomisedRewardItemStackSizeByPrice(chosenItemFromPool);
|
|
}
|
|
|
|
itemsToReturn.push({ item: chosenItemFromPool, stackSize: rewardItemStackCount });
|
|
|
|
const itemCost = this.presetHelper.getDefaultPresetOrItemPrice(chosenItemFromPool._id);
|
|
itemRewardBudget -= rewardItemStackCount * itemCost;
|
|
this.logger.debug(`Added item: ${chosenItemFromPool._id} with price: ${rewardItemStackCount * itemCost}`);
|
|
|
|
// If we still have budget narrow down possible items
|
|
if (itemRewardBudget > 0) {
|
|
// Filter possible reward items to only items with a price below the remaining budget
|
|
exhausableItemPool = new ExhaustableArray(
|
|
this.filterRewardPoolWithinBudget(itemPool, itemRewardBudget, 0),
|
|
this.randomUtil,
|
|
this.cloner,
|
|
);
|
|
|
|
if (!exhausableItemPool.hasValues()) {
|
|
this.logger.debug(`Reward pool empty with: ${itemRewardBudget} roubles of budget remaining`);
|
|
break; // No reward items left, exit
|
|
}
|
|
}
|
|
|
|
// No budget for more items, end loop
|
|
break;
|
|
}
|
|
|
|
return itemsToReturn;
|
|
}
|
|
|
|
/**
|
|
* Choose a random Weapon preset that fits inside of a rouble amount limit
|
|
* @param roublesBudget
|
|
* @param rewardIndex
|
|
* @returns IQuestReward
|
|
*/
|
|
protected getRandomWeaponPresetWithinBudget(
|
|
roublesBudget: number,
|
|
rewardIndex: number,
|
|
): { weapon: IQuestReward; price: number } | undefined {
|
|
// Add a random default preset weapon as reward
|
|
const defaultPresetPool = new ExhaustableArray(
|
|
Object.values(this.presetHelper.getDefaultWeaponPresets()),
|
|
this.randomUtil,
|
|
this.cloner,
|
|
);
|
|
|
|
while (defaultPresetPool.hasValues()) {
|
|
const randomPreset = defaultPresetPool.getRandomValue();
|
|
if (!randomPreset) {
|
|
continue;
|
|
}
|
|
|
|
// Gather all tpls so we can get prices of them
|
|
const tpls = randomPreset._items.map((item) => item._tpl);
|
|
|
|
// Does preset items fit our budget
|
|
const presetPrice = this.itemHelper.getItemAndChildrenPrice(tpls);
|
|
if (presetPrice <= roublesBudget) {
|
|
this.logger.debug(`Added weapon: ${tpls[0]} with price: ${presetPrice}`);
|
|
const chosenPreset = this.cloner.clone(randomPreset);
|
|
|
|
return {
|
|
weapon: this.generatePresetReward(chosenPreset._encyclopedia, 1, rewardIndex, chosenPreset._items),
|
|
price: presetPrice,
|
|
};
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* @param rewardItems List of reward items to filter
|
|
* @param roublesBudget The budget remaining for rewards
|
|
* @param minPrice The minimum priced item to include
|
|
* @returns True if any items remain in `rewardItems`, false otherwise
|
|
*/
|
|
protected filterRewardPoolWithinBudget(
|
|
rewardItems: ITemplateItem[],
|
|
roublesBudget: number,
|
|
minPrice: number,
|
|
): ITemplateItem[] {
|
|
return rewardItems.filter((item) => {
|
|
const itemPrice = this.presetHelper.getDefaultPresetOrItemPrice(item._id);
|
|
return itemPrice < roublesBudget && itemPrice > minPrice;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get a randomised number a reward items stack size should be based on its handbook price
|
|
* @param item Reward item to get stack size for
|
|
* @returns matching stack size for the passed in items price
|
|
*/
|
|
protected getRandomisedRewardItemStackSizeByPrice(item: ITemplateItem): number {
|
|
const rewardItemPrice = this.presetHelper.getDefaultPresetOrItemPrice(item._id);
|
|
|
|
// Define price tiers and corresponding stack size options
|
|
const priceTiers: {
|
|
priceThreshold: number;
|
|
stackSizes: number[];
|
|
}[] = [
|
|
{ priceThreshold: 3000, stackSizes: [2, 3, 4] },
|
|
{ priceThreshold: 10000, stackSizes: [2, 3] },
|
|
{ priceThreshold: Number.POSITIVE_INFINITY, stackSizes: [2] }, // Default for prices 10001+ RUB
|
|
];
|
|
|
|
// Find the appropriate price tier and return a random stack size from its options
|
|
const tier = priceTiers.find((tier) => rewardItemPrice < tier.priceThreshold);
|
|
return this.randomUtil.getArrayValue(tier?.stackSizes || [2]); // Default to 2 if no tier matches
|
|
}
|
|
|
|
/**
|
|
* Should reward item have stack size increased (25% chance)
|
|
* @param item Item to increase reward stack size of
|
|
* @param maxRoublePriceToStack Maximum rouble price an item can be to still be chosen for stacking
|
|
* @param randomChanceToPass Additional randomised chance of passing
|
|
* @returns True if items stack size can be increased
|
|
*/
|
|
protected canIncreaseRewardItemStackSize(
|
|
item: ITemplateItem,
|
|
maxRoublePriceToStack: number,
|
|
randomChanceToPass?: number,
|
|
): boolean {
|
|
const isEligibleForStackSizeIncrease =
|
|
this.presetHelper.getDefaultPresetOrItemPrice(item._id) < maxRoublePriceToStack &&
|
|
!this.itemHelper.isOfBaseclasses(item._id, [
|
|
BaseClasses.WEAPON,
|
|
BaseClasses.ARMORED_EQUIPMENT,
|
|
BaseClasses.AMMO,
|
|
]) &&
|
|
!this.itemHelper.itemRequiresSoftInserts(item._id);
|
|
|
|
return isEligibleForStackSizeIncrease && this.randomUtil.getChance100(randomChanceToPass ?? 100);
|
|
}
|
|
|
|
/**
|
|
* Get a count of cartridges that fits the rouble budget amount provided
|
|
* e.g. how many M80s for 50,000 roubles
|
|
* @param itemSelected Cartridge
|
|
* @param roublesBudget Rouble budget
|
|
* @param rewardNumItems
|
|
* @returns Count that fits budget (min 1)
|
|
*/
|
|
protected calculateAmmoStackSizeThatFitsBudget(
|
|
itemSelected: ITemplateItem,
|
|
roublesBudget: number,
|
|
rewardNumItems: number,
|
|
): number {
|
|
// Calculate budget per reward item
|
|
const stackRoubleBudget = roublesBudget / rewardNumItems;
|
|
|
|
const singleCartridgePrice = this.handbookHelper.getTemplatePrice(itemSelected._id);
|
|
|
|
// Get a stack size of ammo that fits rouble budget
|
|
const stackSizeThatFitsBudget = Math.round(stackRoubleBudget / singleCartridgePrice);
|
|
|
|
// Get itemDbs max stack size for ammo - don't go above 100 (some mods mess around with stack sizes)
|
|
const stackMaxCount = Math.min(itemSelected._props.StackMaxSize, 100);
|
|
|
|
// Ensure stack size is at least 1 + is no larger than the max possible stack size
|
|
return Math.max(1, Math.min(stackSizeThatFitsBudget, stackMaxCount));
|
|
}
|
|
|
|
/**
|
|
* Select a number of items that have a colelctive value of the passed in parameter
|
|
* @param repeatableConfig Config
|
|
* @param roublesBudget Total value of items to return
|
|
* @param traderId Id of the trader who will give player reward
|
|
* @returns Array of reward items that fit budget
|
|
*/
|
|
protected chooseRewardItemsWithinBudget(
|
|
repeatableConfig: IRepeatableQuestConfig,
|
|
roublesBudget: number,
|
|
traderId: string,
|
|
): ITemplateItem[] {
|
|
// First filter for type and baseclass to avoid lookup in handbook for non-available items
|
|
const rewardableItemPool = this.getRewardableItems(repeatableConfig, traderId);
|
|
const minPrice = Math.min(25000, 0.5 * roublesBudget);
|
|
|
|
let rewardableItemPoolWithinBudget = this.filterRewardPoolWithinBudget(
|
|
rewardableItemPool.map((item) => item[1]),
|
|
roublesBudget,
|
|
minPrice,
|
|
);
|
|
|
|
if (rewardableItemPoolWithinBudget.length === 0) {
|
|
this.logger.warning(
|
|
this.localisationService.getText("repeatable-no_reward_item_found_in_price_range", {
|
|
minPrice: minPrice,
|
|
roublesBudget: roublesBudget,
|
|
}),
|
|
);
|
|
// In case we don't find any items in the price range
|
|
rewardableItemPoolWithinBudget = rewardableItemPool
|
|
.filter((x) => this.itemHelper.getItemPrice(x[0]) < roublesBudget)
|
|
.map((x) => x[1]);
|
|
}
|
|
|
|
return rewardableItemPoolWithinBudget;
|
|
}
|
|
|
|
/**
|
|
* Helper to create a reward item structured as required by the client
|
|
*
|
|
* @param {string} tpl ItemId of the rewarded item
|
|
* @param {integer} count Amount of items to give
|
|
* @param {integer} index All rewards will be appended to a list, for unknown reasons the client wants the index
|
|
* @param preset Optional array of preset items
|
|
* @returns {object} Object of "Reward"-item-type
|
|
*/
|
|
protected generateItemReward(tpl: string, count: number, index: number): IQuestReward {
|
|
const id = this.objectId.generate();
|
|
const questRewardItem: IQuestReward = {
|
|
target: id,
|
|
value: count,
|
|
type: QuestRewardType.ITEM,
|
|
index: index,
|
|
items: [],
|
|
};
|
|
|
|
const rootItem = { _id: id, _tpl: tpl, upd: { StackObjectsCount: count, SpawnedInSession: true } };
|
|
questRewardItem.items = [rootItem];
|
|
|
|
return questRewardItem;
|
|
}
|
|
|
|
/**
|
|
* Helper to create a reward item structured as required by the client
|
|
*
|
|
* @param {string} tpl ItemId of the rewarded item
|
|
* @param {integer} count Amount of items to give
|
|
* @param {integer} index All rewards will be appended to a list, for unknown reasons the client wants the index
|
|
* @param preset Optional array of preset items
|
|
* @returns {object} Object of "Reward"-item-type
|
|
*/
|
|
protected generatePresetReward(tpl: string, count: number, index: number, preset?: IItem[]): IQuestReward {
|
|
const id = this.objectId.generate();
|
|
const questRewardItem: IQuestReward = {
|
|
target: id,
|
|
value: count,
|
|
type: QuestRewardType.ITEM,
|
|
index: index,
|
|
items: [],
|
|
};
|
|
|
|
// Get presets root item
|
|
const rootItem = preset.find((item) => item._tpl === tpl);
|
|
if (!rootItem) {
|
|
this.logger.warning(`Root item of preset: ${tpl} not found`);
|
|
}
|
|
|
|
questRewardItem.items = this.itemHelper.reparentItemAndChildren(rootItem, preset);
|
|
questRewardItem.target = rootItem._id; // Target property and root items id must match
|
|
|
|
return questRewardItem;
|
|
}
|
|
|
|
/**
|
|
* Picks rewardable items from items.json
|
|
* This means they must:
|
|
* - Fit into the inventory
|
|
* - Shouldn't be keys
|
|
* - Have a price greater than 0
|
|
* @param repeatableQuestConfig Config file
|
|
* @param traderId Id of trader who will give reward to player
|
|
* @returns List of rewardable items [[_tpl, itemTemplate],...]
|
|
*/
|
|
public getRewardableItems(
|
|
repeatableQuestConfig: IRepeatableQuestConfig,
|
|
traderId: string,
|
|
): [string, ITemplateItem][] {
|
|
// Get an array of seasonal items that should not be shown right now as seasonal event is not active
|
|
const seasonalItems = this.seasonalEventService.getInactiveSeasonalEventItems();
|
|
|
|
// Check for specific baseclasses which don't make sense as reward item
|
|
// also check if the price is greater than 0; there are some items whose price can not be found
|
|
// those are not in the game yet (e.g. AGS grenade launcher)
|
|
return Object.entries(this.databaseService.getItems()).filter(([tpl, itemTemplate]) => {
|
|
// Base "Item" item has no parent, ignore it
|
|
if (itemTemplate._parent === "") {
|
|
return false;
|
|
}
|
|
|
|
if (seasonalItems.includes(tpl)) {
|
|
return false;
|
|
}
|
|
|
|
const traderWhitelist = repeatableQuestConfig.traderWhitelist.find(
|
|
(trader) => trader.traderId === traderId,
|
|
);
|
|
return this.isValidRewardItem(tpl, repeatableQuestConfig, traderWhitelist?.rewardBaseWhitelist);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if an id is a valid item. Valid meaning that it's an item that may be a reward
|
|
* or content of bot loot. Items that are tested as valid may be in a player backpack or stash.
|
|
* @param {string} tpl template id of item to check
|
|
* @returns True if item is valid reward
|
|
*/
|
|
protected isValidRewardItem(
|
|
tpl: string,
|
|
repeatableQuestConfig: IRepeatableQuestConfig,
|
|
itemBaseWhitelist: string[],
|
|
): boolean {
|
|
// Return early if not valid item to give as reward
|
|
if (!this.itemHelper.isValidItem(tpl)) {
|
|
return false;
|
|
}
|
|
|
|
// Check item is not blacklisted
|
|
if (
|
|
this.itemFilterService.isItemBlacklisted(tpl) ||
|
|
this.itemFilterService.isItemRewardBlacklisted(tpl) ||
|
|
repeatableQuestConfig.rewardBlacklist.includes(tpl) ||
|
|
this.itemFilterService.isItemBlacklisted(tpl)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
// Item has blacklisted base types
|
|
if (this.itemHelper.isOfBaseclasses(tpl, [...repeatableQuestConfig.rewardBaseTypeBlacklist])) {
|
|
return false;
|
|
}
|
|
|
|
// Skip boss items
|
|
if (this.itemFilterService.isBossItem(tpl)) {
|
|
return false;
|
|
}
|
|
|
|
// Trader has specific item base types they can give as rewards to player
|
|
if (itemBaseWhitelist !== undefined && !this.itemHelper.isOfBaseclasses(tpl, [...itemBaseWhitelist])) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected getMoneyReward(traderId: string, rewardRoubles: number, rewardIndex: number): IQuestReward {
|
|
// Determine currency based on trader
|
|
// PK and Fence use Euros, everyone else is Roubles
|
|
const currency = traderId === Traders.PEACEKEEPER || traderId === Traders.FENCE ? Money.EUROS : Money.ROUBLES;
|
|
|
|
// Convert reward amount to Euros if necessary
|
|
const rewardAmountToGivePlayer =
|
|
currency === Money.EUROS ? this.handbookHelper.fromRUB(rewardRoubles, Money.EUROS) : rewardRoubles;
|
|
|
|
// Get chosen currency + amount and return
|
|
return this.generateItemReward(currency, rewardAmountToGivePlayer, rewardIndex);
|
|
}
|
|
}
|