Crafting
Module PulseCrafting (depends on PulseInventory). Players turn items into other items: by hand, or at stations such as a workbench or a forge. Crafting takes time, runs in a queue, gives the ingredients back when a job is cancelled, and is saved with the player.
Overview
| Type | What it is |
|---|---|
UPulseRecipe | Data asset (Primary Asset Type PulseRecipe, registered in code for /Game and the content of every plugin; a project entry must have exactly this base class, no Blueprint classes, not editor only): ingredients, tools, outputs, duration, station tags, conditions |
UPulseRecipeBook | Data asset (Primary Asset Type PulseRecipeBook, registered the same way): a list of recipes given to crafters as a whole |
UPulseCraftingComponent | Pulse Crafting: known recipes and the job queue of one player |
UPulseCraftingStationComponent | Pulse Crafting Station: makes an actor a station (Station Settings: tags, speed, range, own inventory; a station id for saves) |
UMVVMPulseCrafting | View model of a crafting menu (recipes, ingredients, queue) |
Setup
- Add Pulse Crafting to an actor the player owns: the pawn, the controller or the player state. The player also needs an inventory (
UPulseInventoryComponent) on one of those actors; ingredients come from it and crafted items go into it. - Create recipes (Miscellaneous > Data Asset > Pulse Recipe) and put them into recipe books.
- Give the crafter the recipes: books in
RecipeBooksof the component, books every crafter knows in Project Settings > Pulse > Gameplay > Crafting > Default Recipe Books, or unlock recipes at runtime (UnlockRecipe,UnlockRecipeById,UnlockRecipeBook), e.g. as a quest reward. Turn offbRequireKnownRecipesfor a sandbox where every recipe works; turn onbListCatalogRecipesto list every recipe of the recipe catalog in menus (creative mode). - For stations, add Pulse Crafting Station to an actor (a workbench) and give it station tags in its Station Settings (
Pulse.Crafting.Station.*). Recipes withRequiredStationTagscan only be crafted at a station that has all of them; recipes without station tags work by hand and at every station. - Start crafting from the UI with
RequestCraft(Recipe, Count, StationActor), or with the node Request Crafting (orRequestCraftingChangein C++) to get the result. On a client the request goes to the server with a request id and the server answers with the result.
Recipes
| Property | Meaning |
|---|---|
DisplayName, Description, Icon | Shown in menus. Empty name or icon: those of the first output. |
Category, SortOrder | Groups and orders recipes in menus (Pulse.Crafting.Category.*). |
Ingredients | Item and count per round. Leave Item empty and set ItemTags for “any item with these tags” (any wood). bIsTool: must be there once, is not used up (hammer). |
Outputs | Item and count per round. Chance for by-products; bRollRandomStats rolls random stats for each crafted item (see Loot and random stats). |
Duration | Seconds per round; 0 crafts at once. |
RequiredStationTags | The station needs all of them. Empty: by hand or at any station. |
Conditions | Pulse conditions (FPulseConditionList, see Conditions, costs and rewards): Actor Tag Query on the crafter, Has Item, skills, quests, … The context: the crafter is Player and Instigator, the owner of the station Target, the recipe Source, the number of rounds Amount, and FPulseCraftingContext the extra data. |
Costs | Pulse costs of one round besides the ingredients (coins, energy, skill points, …). Paid for all rounds when the job starts (Fraction = rounds), together with the ingredients; given back for the rounds that did not run when the job is cancelled (with the costs of the recipe at that time; Items costs give back the very stacks they took, see Jobs). Player crafting only: stations that craft on their own in Pulse Sim do not pay them. |
Fixed ingredients are planned before tag ingredients, so “any wood” does not use up the oak a fixed ingredient needs. Only stacks that may leave the inventory for good are used up (Pulse::Inventory::CanLeaveInventory): lent stacks (items of a skill), bound stacks (Bound trait without Can Transfer) and worn stacks (durability below its maximum; unless Allow Worn Items To Leave of the inventory settings is on) never count as ingredients; tools only need to be there and may be any of them. Data validation reports recipes without outputs and ingredients without item and tags.
The recipe catalog
Recipes and recipe books are known by their id: PulseRecipe:<name> and PulseRecipeBook:<name>, the primary asset ids of their assets. Requests, queues, unlocked recipes and saves keep the id and find the recipe through the definitions of PulseFoundation (Pulse::Definitions): recipes the game registered at runtime first, then the catalog of the kind. By default that catalog reads the data assets through the asset manager; a studio names its own catalog class per kind in Project Settings > Pulse > Foundation > Definitions > Definition Catalogs.
Pulse::Crafting::Recipes (PulseRecipeCatalog.h) and the Blueprint library Pulse Recipe Catalog (Pulse|Crafting|Catalog): GetRecipeId / Get Recipe Id, FindRecipe / Find Recipe, LoadRecipeSynchronous, LoadRecipe (Blueprint: Load Pulse Definition with class Pulse Recipe), GetRecipeIds / Get All Recipe Ids, RegisterRecipe / Register Recipe, UnregisterRecipe / Unregister Recipe, ParseRecipeId, and the same for recipe books (GetRecipeBookId, FindRecipeBook, LoadRecipeBook, RegisterRecipeBook, …). A recipe made at runtime is named after its id, the same name on every machine, and registered on the server and on every client that shows it.
Recipes on a difficulty
Tuning sources (a difficulty of Pulse Difficulty, server rules, an area) change recipes with adjustments of PulseCrafting, besides the knobs Pulse.Tuning.Crafting.*:
- Change Recipe (
FPulseAdjustment_Recipe): one recipe; ingredients replaced, removed or added, counts of ingredients and outputs, a factor of the duration, extra station tags. What is not set follows the recipe. Extra station tags count everywhere a station is checked: by hand and at another station the recipe cannot be crafted and is left out ofGetKnownRecipes, a station in Pulse Sim refuses it (Wrong Station). - Change Recipes by Rule (
FPulseAdjustment_RecipeRule): every recipe a filter selects (category query, recipe books, station tags, tags of an output item): an ingredient replaced with a factor, an extra ingredient, counts. - Lock Recipes (
FPulseAdjustment_RecipeLock): recipes or whole books cannot be crafted (Not Allowed); a later adjustment with Locked off unlocks them again. The lock is checked inCheckRecipe, soCanCraft,StartCraftingandGetMaxCraftable(0) all see it, and a station in Pulse Sim does not queue a locked recipe. Locked recipes stay inGetKnownRecipes, so a menu can show them with the reason. - Swap Asset of PulseFoundation uses a variant of the recipe; the adjustments then change the variant. Change Recipe entries of the recipe and of the variant both apply (the recipe’s first), and a lock that names either one (or a book of either one) locks it.
Recipe books named by a rule or a lock are loaded the first time they are checked when they are not loaded yet, so the answer is the same on the server and on every client; keep them referenced (by the preset or the tuning source) to avoid a hitch.
Pulse::Crafting::GetEffectiveRecipe applies them in that order and caches a transient copy per world, recipe and set of adjustments; a recipe asset that is edited or reloaded in the editor gives a new copy, and the copies of a world go when it is cleaned up. GetTuning puts the copy, the lock and one line per change (Changes, for menus: “+1 Leather”) into FTuning, so every rule that takes the tuning plans with the changed recipe. The recipe view model (UMVVMPulseRecipe) shows the ingredients, outputs and duration of the changed recipe and its Changes lines. Jobs and saves keep the recipe itself; the copy is only planned with. Specs: PulseCrafting.Adjustments.
Recipes in the editor
Recipes and recipe books open in the config workshop of the Pulse Editor Kit (graph, details, validation, notes), with a preview of PulseGameplay on the right. Both previews have a button per difficulty level of Pulse Difficulty (Base is the asset as it is): the level’s adjustments (Swap Asset, Change Recipe, rules, locks) and the knobs Pulse.Tuning.Crafting.* are applied without a world, the same way GetTuning does it in a game (without a station and without the conditions of a crafter).
Recipe (tab of a recipe):
- Recipe card: the ingredients with their counts on the left (tools in a dashed box, they are not used up), an arrow with the time of a round, the outputs with count and chance on the right; below the station tags (or “by hand”), the time, the variant of a swap, one line per change of the level and per knob that changes it (in the warning color), and Locked on this level when a Lock Recipes adjustment locks it.
- Raw materials: one round followed through the recipes that make the ingredients (rounds rounded up: 6 planks from a recipe that makes 4 need 2 rounds) down to items no recipe makes; tools are left out, a chain that leads back to an item is reported as a loop and not followed.
- Where used: recipe books, presets and other assets that name the recipe, with a button that opens them.
- Test Craft (the live test tab next to the details): a test inventory with one row per ingredient item (an ingredient by tags takes the first known item that fits), starting with what one round needs on the level; change the counts and the result shows how many rounds they are enough for and what is missing, from the planning rules of the game (
GetMaxRounds,GetIngredientStatus) with the recipe and the knobs of the level. Stations, conditions and costs are not checked.
Tree (tab of a recipe book): the crafting tree of the book. Each item the book makes, the recipe that makes it (←) and its ingredients, followed through every recipe of the project down to items no recipe makes (at most six item levels deep). Warnings name the items no recipe makes (raw materials: make sure gathering, loot or a shop gives them) and the items of cycles (made in the end from themselves). The level buttons switch to the recipes of a level; a recipe that is locked or changed there is marked. Open in Pulse Tables lists the recipes of the book in Pulse Tables to edit counts, times and stations side by side.
The rules behind both previews are pure functions of the editor module (Pulse::Crafting::Editor: MakeLevelRecipe, CollectBaseMaterials, BuildCraftTree). Spec: PulseGameplay.Editor.RecipeWorkshop.
Stations
Everything a station allows is one value, Station Settings (FPulseCraftingStationSettings): StationTags, SpeedMultiplier, UseRange, bUseStationInventory, bOutputToStationInventory. Blueprint reads the property and writes it with Set Station Settings; C++ uses GetStationSettings / SetStationSettings (and GetStationTags, GetSpeedMultiplier). Setting it is allowed on the authority (and on every machine before BeginPlay); a change fires OnSettingsChanged / OnSettingsChangedNative there and on clients when it arrives. Equal settings fire nothing.
Station ids. A saved job finds its station again by the station id (GetStationId), made from the Save Identity of the station (FPulseSaveIdentity of Pulse Foundation, scope World by default):
- Stations placed in a level work without setup: their id is made from the actor and component names and the streamed level they are in (so the same layout in two sublevels or level instances gives two ids). Renaming the actor or the component loses the station of saved jobs.
- Stations spawned while playing need a Key (for example from the spawner’s own id), set before the actor finished spawning (deferred spawn) or with Set Save Identity. Without a Key the station has no id and its jobs are saved without station.
- Two stations with one id (a Key used twice) find none of their saved jobs: the registry logs a warning, and such a job counts as having lost its station until one of them gets its own Key.
FindStationById(WorldContext, Id) finds a registered station (authority; stations register in BeginPlay).
With Pulse Water, the bridge PulseWaterGameplayBridge adds shipyards: a station with a slipway whose recipes build boats (the output is an item with the item trait Boat) and launch them on the water; see “Shipyard and repairs” in the Pulse Water docs.
Stations that craft on their own (Pulse Sim)
A sawmill, a smelter or a cooking fire can craft on its own, also while its chunk is unloaded and nobody is near. Turn on Crafts On Its Own on the station component (category Sim). The station then is a Pulse Sim record (FPulseSimState_CraftingStation) with its own queue; the crafting of players does not change.
- Stashes: the ingredients of each round come from Source Stash Ids, the crafted items go to Output Stash Id: inventories with Keep In Pulse Sim (see the inventory page). Empty fields use the station’s own inventory if it keeps its contents in Pulse Sim, so a station with one inventory takes from it and puts into it.
- Jobs: Enqueue On Station (server) queues rounds of a recipe; the station’s tags and speed apply, at most Max Station Queue Length jobs. Cancel On Station gives the ingredients of the running round and the items that wait for room back into the first source stash. Get Station Queue and On Station Queue Changed work on the server and on clients near the station (the record replicates by cell).
- Time: rounds are events on the game clock: they pause with it, and a station that was far away catches up when someone looks at it, with the same result as step by step (the outputs are rolled with a seed of the station id and the round). A missing ingredient or a full output stash lets the station rest; a change of one of its stashes wakes it.
- The station id (
GetStationId) is the record id: placed stations have one, spawned stations need a Key in Save Identity. Overflow Drop does not apply: the station waits for room. - Every job keeps the id of its recipe (
RecipeId) next to the pointer, so a record loaded from a region save finds a recipe made at runtime by its id (registered again before the load). - In C++:
Pulse::Crafting::Sim::EnqueueAt/CancelAt(server, by station id), orEnqueue/Cancelon a record.
Jobs
StartCrafting(Recipe, Count, Station) (authority) or RequestCraft (any machine) checks the recipe and queues a job:
- All or nothing: the start is one exchange of Pulse Foundation (
Pulse::Crafting::MakeCraftExchange): the costs of the recipe for all rounds, then the ingredients of all rounds, taken at once from the player’s inventory and, if the station allows it (bUseStationInventory), from the station’s inventory, and the job is queued. One plan covers all rounds (Pulse::Crafting::PlanRounds), so every round finds the items the check found; it is split per round for exact refunds. If anything is missing, nothing is taken. Each source inventory fires its events once, after the job is queued. - One after the other: only the first job of the queue runs; one round after the other. A station’s
SpeedMultipliershortens the rounds. - Output: the crafted items go into the player’s inventory, or the station’s (
bOutputToStationInventory). What does not fit is dropped next to the station or the crafter (Overflow = Drop), or the job waits until there is room (Overflow = Wait). - Cancel:
CancelJob/RequestCancelJobgives back exactly the items the unfinished rounds took and the costs of the recipe for those rounds; items that were already crafted are handed out. The stacks the Items costs took are kept with the job (FPulseCraftingJob::PaidItems, with their instance traits and the cost that took each), and the refund gives those back (Pulse::Inventory::FItemCostLedger): a bound key comes back bound, a worn tool worn, not as new items. Each cost gets only the stacks it took, also when a cancel gives back only some rounds: with the costsMeat x1andFood x1(by tag; meat is food) paid with meat and fish, the rounds that did not run give meat and fish back, never two meat. - Station gone: with
bCancelWhenStationLosta job whose station was destroyed is cancelled when its round ends; so is a loaded job whose station id is not registered (or shared by two stations) at that moment. Without it the job finishes without its station (into the player’s inventory). A loaded job whose station registers later finds it. - Empty rounds: a round whose outputs all failed their chance still counts (
OnRoundCrafted), the job does not wait. MaxQueueLengthlimits the jobs,MaxRoundsPerJob(settings) the rounds of one job.
Rules of the game. CanCraftRecipe(Recipe, Count, Station) is a Blueprint native event that the crafter asks after its own checks passed (in CanCraft, StartCrafting and the job step of the exchange; on the authority and on the owner for the menu). Return a failure with a reason of your game (“Only at night”) to refuse; the reason and its text reach the menu and the answer of the request unchanged. A failure without a reason gets Pulse.Result.Failure.Crafting.NotAllowed. The default allows everything. CheckCraft reports a refusal as NotAllowed with its text.
CanCraft runs the same checks without changing anything. Like StartCrafting, CancelJob and the station’s EnqueueOnStation / CancelOnStation it returns an FPulseResult of PulseFoundation: success, or the reason with a text for the player (Get Display Text). The reasons of crafting are Pulse.Result.Failure.Crafting.UnknownRecipe, .MissingIngredients, .WrongStation, .TooFar (UseRange of the station), .QueueFull, .NotAllowed and .NoInventory with registered texts (replace them in the Result Texts of the Pulse Foundation settings); a condition that fails is Conditions with its line as the message (“Needs the forge key”), costs that cannot be paid Costs with the cost lines, a missing job NotFound, a bad recipe or count Invalid. The rules keep EPulseCraftingResult (CheckCraft in C++, the queue, the Sim of stations); Pulse::Crafting::ToResult maps a code. GetMaxCraftable says how many rounds the ingredients are enough for.
Client requests (RequestCraft, RequestCancelJob, RequestCraftingChange with an FPulseCraftingRequest) carry an id of the request subsystem of PulseFoundation. A craft request sends the recipe as its id (FPulseCraftingRequest::RecipeId, filled from Recipe when it is empty; Recipe itself is not sent), and the server finds the recipe by it, so recipes made at runtime work; in C++ set Recipe or RecipeId; the server lets them in with its guard (kinds Pulse.Request.Crafting.Craft, .CancelJob), checks that the player may change the source and output inventories (HandleRequest) and answers with the result; a failure also arrives as Pulse.Message.Request.Failed.
The start as an exchange (C++)
Pulse::Crafting::MakeCraftExchange(Recipe, Count, Crafter, Station) (PulseCraftingExchange.h) builds the exchange of a start without changing anything: one party (the crafter, MakeCostContext: the context of the conditions with Fraction = rounds), the Costs step of the recipe if it has costs, and FPulseCraftingExchangeStep_Job (checks everything CanCraft checks, takes the ingredients and queues the job; Undo removes the job and gives the ingredients back, the costs come back through their own step). The costs step is FPulseCraftingExchangeStep_Costs, a Costs step that pays inside an item cost ledger and hands the stacks its Items costs took to the job. Add steps of your own (a fee of a workshop owner) and run it with Pulse::Exchange::Run; GetExchangeResult gives the EPulseCraftingResult and the text. A job queued by an exchange that StartCrafting did not run starts on the next frame.
Override GetSourceInventories and GetOutputInventory (Blueprint native events) for other rules, e.g. a shared storage of the base. Crafting and the view model use GetCraftingSources: the sources without empty entries and duplicates, so an inventory returned twice is counted and taken from once. When a station inventory is used, it must allow the player to change it (UPulseInventoryComponent::CanRequesterModify), otherwise client requests are rejected.
Tuning
Three tuning knobs of PulseFoundation change every recipe without touching the assets. The recipe is the source of the context, its category and the tags of the station are the tags, the crafter is the player:
| Knob | Changes | Read |
|---|---|---|
Pulse.Tuning.Crafting.Ingredients | Counts of the ingredients, rounded up, at least 1; tools stay | When a job is planned: a running job keeps the items it took (RoundIngredients), so a change never makes or destroys items |
Pulse.Tuning.Crafting.Outputs | Counts of the outputs, rounded, at least 1 | When a round is done |
Pulse.Tuning.Crafting.Duration | Seconds of a round (before the speed of the station) | When a job starts; the job keeps its time |
Stations that craft on their own in Pulse Sim read the same knobs with the recipe and the station tags. The crafting view model shows the tuned numbers. The pure rules take the values as Pulse::Crafting::FTuning (Pulse::Crafting::GetTuning), so specs test them without a world.
Events and messages
Every change of the queue is one operation (start, cancel, cancel all, a finished round, a delivery after room was made, an import). Its events fire after the whole change, when the queue holds its final state: first the inventory events of the crafter’s own changes (one OnInventoryChanged per applied change, each with its stack snapshot), then the queue events in the order they happened, then OnQueueChanged once. A listener that calls back into the crafter (StartCrafting, CancelJob) gets its result at once; the events of its call fire after the running ones.
| Event (native and Blueprint) | When |
|---|---|
OnQueueChanged | Job added, round finished, job finished or cancelled: once per operation on the authority, on the owner when the queue arrives |
OnRoundCrafted | A round was finished and its items handed out (authority) |
OnJobCompleted, OnJobCancelled | A job finished all its rounds, or was cancelled (authority) |
OnRecipeUnlocked | A recipe was unlocked (authority and owner; on the owner when its recipe arrived) |
OnRecipesChanged | The known recipes changed: unlocked, forgotten or loaded, a recipe of the unlocked list or of the catalog arrived, the recipe definitions changed (authority and owner) |
Message bus channels (payload FPulseCraftingMessage, sent on the server): Pulse.Message.Crafting.Queued, .Crafted, .Completed, .Cancelled, .RecipeUnlocked. Their context names the crafter as Player and Instigator, the station’s owner as Target, the recipe as Source and the rounds as Amount (1 for .Crafted and .RecipeUnlocked). Quests and achievements can count crafted items with them without a bridge.
Multiplayer
The server decides everything. The queue and the unlocked recipes replicate to the owner only; the Station Settings replicate to everybody as one property (push model). Jobs replicate their station id and the station reference.
Recipes travel as ids: jobs replicate RecipeId (their Recipe is not replicated; a request names its recipe by RecipeId, and the server loads a recipe that is not in memory only when the player may craft it: Require Known Recipes off, List Catalog Recipes on, an unlocked id or a recipe of the known books), the crafter replicates UnlockedRecipeIds (UnlockedRecipes is a cache on every machine, GetUnlockedRecipeIds reads the ids). The owner resolves the recipes through the catalog; a job whose recipe still loads has no Recipe and stays out of the menu until it arrived (OnQueueChanged fires again), an unlocked recipe counts from its arrival (OnRecipeUnlocked, OnRecipesChanged). Progress (GetRoundProgress, GetRoundTimeLeft) is computed from the Pulse game clock, so nothing ticks; on clients it can lag a little behind the server. Rounds of a player run on the game clock too: they pause with it, follow its rate and finish at once when it jumps past their end (a rest of PulseTime).
Crafting menus
UMVVMPulseCrafting feeds a menu: call SetCrafter (with FindCraftingComponent of the player) and SetStation.
Recipes(UMVVMPulseRecipe): name, icon, category, duration at this station,bCanCraftwithReason,MaxCraftable,Ingredients(available and needed per ingredient) andOutputs.Jobs(UMVVMPulseCraftingJob): recipe, rounds left, running or waiting for room;GetProgressandGetTimeLeftfor a progress bar,RequestCancel.Categories,SetCategoryFilter,bQueueFull,RequestCraft.
The view model refreshes when the queue, the known recipes (OnRecipesChanged, also when recipe definitions are registered or loaded) or the source inventories change. Jobs whose recipe is still loading on this machine are left out.
Saving
ExportSaveData / ImportSaveData and SaveToBytes / LoadFromBytes (versioned) save the unlocked recipes and the queue, including the items each unfinished round took and the progress of the running round. A loaded job continues where it stopped (the first job with the progress of its own saved entry) and finds its station by its station id (save data version 3; see Stations) and keeps the stacks its costs took (version 4, PaidItems; a job of older data gives new items back for its Items costs) with the cost that took each (version 5, CostItem, CostItemId, CostItemTag; the stacks of version 4 data have none and go to any refund whose item they match). A job whose recipe no longer exists is refunded; the import first replaces recipes and queue in one step and gives the refunds back afterwards, so inventory listeners already see the loaded queue. Recipes and items are saved by their primary asset id (PulseRecipe:<name>, PulseItem:<name>) with the path as fallback; the id is found through the recipe catalog and the item catalog, so moved assets and recipes made at runtime (registered again before the load) still load; the catalog has to answer at once (Load Definition Synchronous), an id that does not is left out with a warning that names the catalog (save data version 2: every unlocked recipe is one FPulseCraftingSavedRecipe entry in Recipes with id and path; version 1 data still loads from UnlockedRecipes by path). Recipe and recipe book asset names must be unique within their type, like item names (a copy of a plugin recipe or book under /Game may keep its name: the project asset wins).
The component saves itself as bytes (IPulseByteSaveable, save identity Pulse.Crafting.Save.Crafter): PulseSave keeps it without a bridge, it loads after the inventories (load priority -10), and a respawn keeps or resets it by its tag (Reset: no unlocked recipes, an empty queue). Messages sent while a save is imported carry CatchUp Load.
Rules without a world
The rules of crafting are plain functions in Pulse::Crafting, so specs and other code can use them without components:
| Header | Functions |
|---|---|
PulseCraftingRules.h | PlanRounds (one plan for all rounds of a job, split per round, tools apart), PlanIngredients (its total), GetMaxRounds, GetIngredientStatus, IsStationSuitable, RollRoundOutputs (chances and random stats of one round), GetRoundDuration (station speed, instant crafting), IsWithinUseRange |
PulseCraftingQueue.h | FPulseCraftingQueue (jobs, next id) with CheckEnqueue, Enqueue, Next (the state machine of the first job: wait, craft, deliver), FinishRound, ConfirmDelivery, Cancel, GetStationAvailability, GetRoundProgress, GetRoundTimeLeft, ToSavedStack, MakeSavedJobs, QueueFromSave; the functions report what happened as events in order |
Specs: PulseCrafting.Plan and PulseCrafting.Queue; PulseCrafting.Catalog (requests by RecipeId and when the server loads their recipe, the owner’s queue and unlocked recipes by id, also from a catalog that loads in the background, unlock and forget by id with a save, bListCatalogRecipes, CanCraftRecipe); the exchange of a start (costs, cancel with refund, undo, a stale exchange) in PulseCrafting (group Exchange); the view model classes of the settings and their fallback in PulseCrafting (group View model classes).
Settings
Project Settings > Pulse > Gameplay > Crafting (UPulseCraftingSettings):
| Setting | Default | Meaning |
|---|---|---|
DefaultRecipeBooks | empty | Recipe books every crafter knows. |
MaxRoundsPerJob | 99 | Most rounds of one job. |
DropScatterRadius | 60 | Spread of dropped items (cm). |
RecipeViewModelClass | UMVVMPulseRecipe | View model of one recipe in a crafting menu, created by UMVVMPulseCrafting; a child (C++ or Blueprint) adds fields of its own, empty uses the base class. |
CraftingJobViewModelClass | UMVVMPulseCraftingJob | View model of one job of the queue, created by UMVVMPulseCrafting; empty uses the base class. |
Debugging
- Every crafting component is a snapshot provider (category
Crafting): queue, progress and waiting jobs show on the Live page of the Pulse Debugger and withPulseDebugDump Crafting. - Queued, crafted and cancelled jobs are timeline events (source
Crafting). - Cheats and
Pulse.Crafting.Instant: see Console.