This class handles all calculations around work, using statistics and information from the pspccharacterinfo Prop Classes for both the worker and the target. More...

#include <workmanager.h>

Public Member Functions
void	HandleCombine (Client *client)
	Start Combine work This gets called when the player tries to combine items in a container using /combine command.
void	HandleConstruct (Client *client)
	Begins construction work.
void	HandleProduction (gemActor actor, const char type, const char *reward)
	Handle production events from super clients.
void	HandleUse (Client *client)
	Handles using an item for working.
bool	LoadLocalVars (Client client, gemObject target=NULL)
	Sets up the internal structure of the work manager to handle a particular client.
void	StartAutoWork (Client client, gemContainer container, psItem *autoItem, int count)
	Start a work event for this client.
void	StartLockpick (Client client, psItem item)
	Lockpicking.
bool	StartScriptWork (Client client, gemObject target, csString pattern)
	Checks to see if the progression script generated craft work can be done.
void	StopWork (Client client, psItem item)
	Stop work event.
	WorkManager (CacheManager cachemanager, EntityManager entitymanager)
virtual	~WorkManager ()
Work Event Handlers
These are the functions fired when a psWorkGameEvent is Triggered.
void	HandleWorkEvent (psWorkGameEvent *workEvent)
	Handles a transformation/combination event.
void	HandleCleanupEvent (psWorkGameEvent *workEvent)
	Handles a cleanup event.
void	HandleProductionEvent (psWorkGameEvent *workEvent)
	Handles a resource/harvesting event.
void	HandleRepairEvent (psWorkGameEvent *workEvent)
	Handles a repair event, which occurs after a few seconds of repairing an item.
void	LockpickComplete (psWorkGameEvent *workEvent)
Static Public Member Functions
Constraint Functions
static bool	constraintTime (WorkManager that, char param)
static bool	constraintFriends (WorkManager that, char param)
static bool	constraintLocation (WorkManager that, char param)
static bool	constraintMode (WorkManager that, char param)
static bool	constraintGender (WorkManager that, char param)
static bool	constraintRace (WorkManager that, char param)
Protected Member Functions
bool	AnyCombination (csArray< psItem * > itemArray, uint32 &resultId, int &resultQty)
	Returns with the result ID and quantity of the combination if the item list is in set of unique ingredients for that pattern.
unsigned int	AnyTransform (csArray< psTradePatterns * > &patterns, float &KFactor, uint32 targetId, int targetQty)
	Check to see if there is a possible trasnform available.
void	ApplyProcessScript (psItem oldItem, psItem newItem, gemActor worker, psTradeProcesses process, psTradeTransformations *trans)
	Applies the mathscript defined for the process over items being produced.
int	CalculateEventDuration (psTradeTransformations trans, psTradeProcesses process, psItem transItem, gemActor worker)
	Calculates the event duration to accomplish a work using a math script.
bool	CalculateQuality (float factor, psItem transItem, gemActor worker, bool amountModifier, float &currentQuality, psTradeProcesses process, psTradeTransformations trans, csTicks time)
	Calculates the quality of the item based on the skills applied.
bool	CheckStamina (psCharacter *owner) const
psItem *	CombineContainedItem (uint32 newId, int newQty, float itemQuality, psItem *containerItem)
bool	CombineWork ()
psItem *	CreateTradeItem (uint32 newId, int newQty, float itemQuality, bool transient=false)
csArray< NearNaturalResource >	FindNearestResource (iSector sector, csVector3 &pos, const size_t action, const char reward=NULL)
	Find the nearest resource to the player of the requested type.
void	HandleLockPick (MsgEntry me, Client client)
void	HandleProduction (gemActor actor, size_t type, const char reward, Client *client=NULL)
	Handle production events from clients.
void	HandleRepair (gemActor actor, Client client, const csString &repairSlotName)
	This function handles commands like "/repair" using the following sequence of steps.
void	HandleWorkCommand (MsgEntry me, Client client)
void	Initialize ()
bool	IsContainerCombinable (uint32 &resultId, int &resultQty)
	Returns with the result ID and quantity of the combination if work item container has the correct items in the correct amounts.
bool	IsHandCombinable (uint32 &resultId, int &resultQty)
	Returns with the result ID and quantity of the combination if player has the correct items in the correct amounts in hand.
bool	IsIngredient (uint32 patternId, uint32 targetId)
bool	IsOnHand (uint32 equipId)
unsigned int	IsTransformable (uint32 patternId, uint32 targetId, int targetQty)
	Check to see if there is a possible trasnform available.
bool	MatchCombinations (csArray< psItem * > itemArray, CombinationConstruction *current, int &multiplier)
	Returns true then item array matchs combination array regardless of order.
bool	SameProductionPosition (gemActor *actor, const csVector3 &startPos)
bool	ScriptAction (gemActionLocation *gemAction)
bool	ScriptActor (gemActor *gemAct)
bool	ScriptItem (gemItem *gemItm)
bool	ScriptNoTarget ()
void	SendTransformError (uint32_t clientNum, unsigned int result, uint32 curItemId=0, int CurItemQty=0)
	Sends an error message to the client based on the trade pattern error.
void	StartCleanupEvent (int transType, Client client, psItem item, gemActor *worker)
void	StartCombineWork (Client *client)
	Checks to see if the work container item can be used for combining.
void	StartConstructWork (Client *client)
	Checks to see if the item can be constructed.
void	StartTransformationEvent (int transType, INVENTORY_SLOT_NUMBER transSlot, int resultQty, float resultQuality, psItem *autoItem)
void	StartUseWork (Client *client)
	Checks to see if the item can be used for working.
void	StopAutoWork (Client client, psItem autoItem)
	Stop auto work event.
void	StopCleanupWork (Client client, psItem cleanItem)
	Handles stopping the cleanup event for a particular item.
void	StopCombineWork (Client *client)
	Handles stopping the combining in the work container.
void	StopConstructWork (Client *client)
	Handles stopping the constructing of an item.
void	StopUseWork (MsgEntry me, Client client)
	Handles stopping the use of the item for working.
psItem *	TransformContainedItem (psItem oldItem, uint32 newId, int newQty, float itemQuality, psTradeProcesses process, psTradeTransformations *trans)
psItem *	TransformSelfContainerItem (psItem oldItem, uint32 newId, int newQty, float itemQuality, psTradeProcesses process, psTradeTransformations *trans)
psItem *	TransformSlotItem (INVENTORY_SLOT_NUMBER slot, uint32 newId, int newQty, float itemQuality, psTradeProcesses process, psTradeTransformations trans)
psItem *	TransformTargetItem (psItem oldItem, uint32 newId, int newQty, float itemQuality, psTradeProcesses process, psTradeTransformations *trans)
void	TransformTargetItemToNpc (psItem workItem, Client client)
psItem *	TransformTargetSlotItem (INVENTORY_SLOT_NUMBER slot, uint32 newId, int newQty, float itemQuality, psTradeProcesses process, psTradeTransformations trans)
bool	ValidateCombination (csArray< psItem * > itemArray, uint32 &resultId, int &resultQty)
	Returns with the result ID and quantity of the combination if the item list matches every item in a valid combination.
bool	ValidateConstraints (psTradeTransformations transCandidate, psTradeProcesses processCandidate)
bool	ValidateMind ()
bool	ValidateNotOverSkilled (psTradeTransformations transCandidate, psTradeProcesses processCandidate)
bool	ValidateSkills (psTradeTransformations transCandidate, psTradeProcesses processCandidate)
bool	ValidateStamina (Client *client)
bool	ValidateTarget (Client *client)
bool	ValidateTraining (psTradeTransformations transCandidate, psTradeProcesses processCandidate)
bool	ValidateWork ()
Protected Attributes
MathScript *	calc_combine_quality
	This is the calculation for the quality of combined work items.
MathScript *	calc_lockpick_time
	This is the calculation for how long it takes to pick a lock.
MathScript *	calc_lockpicking_exp
	This is the calculation for the experience to assign to player for lockpicking.
MathScript *	calc_mining_chance
	This is the calculation for chance of successful mining.
MathScript *	calc_mining_exp
	This is the calculation for the experience to assign to player for mining.
MathScript *	calc_repair_exp
	This is the calculation for the experience to assign to player for repairing.
MathScript *	calc_repair_quality
	This calculates the item ending quality and max quality at the end of repair.
MathScript *	calc_repair_rank
	This is the calculation for how much skill is required to repair.
MathScript *	calc_repair_result
	This is the calculation for how many points of quality are added in a repair.
MathScript *	calc_repair_time
	This is the calculation for how long a repair takes.
MathScript *	calc_transform_apply_skill
	This is the calculation for the quality resulting from the item.
MathScript *	calc_transform_exp
	This is the calculation for the experience to assign to player for trasformations.
MathScript *	calc_transform_practice
	This is the calculation for the practice to assign to player for trasformations.
MathScript *	calc_transform_time
	This is the calculation for the time needed to accomplish a transformation.
csPDelArray< NaturalResource >	resources
	list of all natural resources in game.
csStringArray	resourcesActions
	List of all actions usable with natural resources.

Detailed Description

This class handles all calculations around work, using statistics and information from the pspccharacterinfo Prop Classes for both the worker and the target.

Definition at line 159 of file workmanager.h.

Constructor & Destructor Documentation

WorkManager::WorkManager	(	CacheManager *	cachemanager,
		EntityManager *	entitymanager
	)

virtual WorkManager::~WorkManager ( ) [virtual]

Member Function Documentation

bool WorkManager::AnyCombination	(	csArray< psItem * >	itemArray,
		uint32 &	resultId,
		int &	resultQty
	)		`[protected]`

Returns with the result ID and quantity of the combination if the item list is in set of unique ingredients for that pattern.

Parameters:

itemArray	The array of items that need to be checked.
resultId	The item ID of the resulting item.
resultQty	The stack quantity of the resulting item.

Returns:: False if combination is not possible.

unsigned int WorkManager::AnyTransform	(	csArray< psTradePatterns * > &	patterns,
		float &	KFactor,
		uint32	targetId,
		int	targetQty
	)		`[protected]`

Check to see if there is a possible trasnform available.

Parameters:

patterns	The list of all applicable patters to apply (including group patterns)
KFactor	The KFactor
targetId	The id of the item trying to transform.
targetQty	The stack count of the item to transform.

Returns:: An indicator of pattern match status.

void WorkManager::ApplyProcessScript	(	psItem *	oldItem,
		psItem *	newItem,
		gemActor *	worker,
		psTradeProcesses *	process,
		psTradeTransformations *	trans
	)		`[protected]`

Applies the mathscript defined for the process over items being produced.

It checks if there is a mathscript defined (empty string to disable), if it's defined it will try to recover the mathscript if available, if it succeeds it sets NewItem OldItem Worker and Process in the math environment and runs the script. The function has no return as the mathscript is supposed to apply the effects directly on the targets passed in the environmnent.

Parameters:

oldItem	The item which is going to be destructed (the old item).
newItem	The newly created item.
worker	The actor which is working on the item.
process	The process applied to create the new item by the worker.
trans	The transform applied to create the new item by the worker.

int WorkManager::CalculateEventDuration	(	psTradeTransformations *	trans,
		psTradeProcesses *	process,
		psItem *	transItem,
		gemActor *	worker
	)		`[protected]`

Calculates the event duration to accomplish a work using a math script.

Parameters:

trans	The transformation which is being applied.
process	The process.
transItem	The item which is being transformed.
worker	The actor which is working on the object.

Returns:: The amount of time which will be needed to complete the work.

bool WorkManager::CalculateQuality	(	float	factor,
		psItem *	transItem,
		gemActor *	worker,
		bool	amountModifier,
		float &	currentQuality,
		psTradeProcesses *	process,
		psTradeTransformations *	trans,
		csTicks	time
	)		`[protected]`

Calculates the quality of the item based on the skills applied.

bool WorkManager::CheckStamina ( psCharacter * owner ) const [protected]

psItem* WorkManager::CombineContainedItem	(	uint32	newId,
		int	newQty,
		float	itemQuality,
		psItem *	containerItem
	)		`[protected]`

Parameters:

newId	The new ID
newQty	The new number of items.
itemQuality	The new items quality.
containerItem	The container.

bool WorkManager::CombineWork ( ) [protected]

static bool WorkManager::constraintFriends	(	WorkManager *	that,
		char *	param
	)		`[static]`

static bool WorkManager::constraintGender	(	WorkManager *	that,
		char *	param
	)		`[static]`

static bool WorkManager::constraintLocation	(	WorkManager *	that,
		char *	param
	)		`[static]`

static bool WorkManager::constraintMode	(	WorkManager *	that,
		char *	param
	)		`[static]`

static bool WorkManager::constraintRace	(	WorkManager *	that,
		char *	param
	)		`[static]`

static bool WorkManager::constraintTime	(	WorkManager *	that,
		char *	param
	)		`[static]`

psItem* WorkManager::CreateTradeItem	(	uint32	newId,
		int	newQty,
		float	itemQuality,
		bool	transient = `false`
	)		`[protected]`

csArray<NearNaturalResource> WorkManager::FindNearestResource	(	iSector *	sector,
		csVector3 &	pos,
		const size_t	action,
		const char *	reward = `NULL`
	)		`[protected]`

Find the nearest resource to the player of the requested type.

Parameters:

sector	A pointer to the iSector the player is currently in.
pos	A csVector3 with the position of the player in the current sector.
action	The position in the resourcesActions array of the requested production type.
reward	The name of the natural resource we are looking for.

void WorkManager::HandleCleanupEvent ( psWorkGameEvent * workEvent )

Handles a cleanup event.

Basically removing discarded items from public containers.

Parameters:

workEvent The work event that was in the queue to fire.

void WorkManager::HandleCombine ( Client * client )

Start Combine work This gets called when the player tries to combine items in a container using /combine command.

Parameters:

client The client that combines

void WorkManager::HandleConstruct ( Client * client )

Begins construction work.

This is called when a player attempts to build a constructable item.

Parameters:

client The client that construct

void WorkManager::HandleLockPick	(	MsgEntry *	me,
		Client *	client
	)		`[protected]`

void WorkManager::HandleProduction	(	gemActor *	actor,
		size_t	type,
		const char *	reward,
		Client *	client = `NULL`
	)		`[protected]`

Handle production events from clients.

This function handles commands like "/dig for gold" using the following sequence of steps:

Make sure client isn't already busy digging, etc.
Find closest natural resource
Validate category of equipped item
Calculate time required
Send anim and confirmation message to client
Queue up game event for success

Parameters:

actor	The actor
type	The position in the resourcesActions array of the requested production type.
reward	The name of the natural resource we are looking for.
client	The client that issues the command

void WorkManager::HandleProduction	(	gemActor *	actor,
		const char *	type,
		const char *	reward
	)

Handle production events from super clients.

void WorkManager::HandleProductionEvent ( psWorkGameEvent * workEvent )

Handles a resource/harvesting event.

Basically the production events.

Parameters:

workEvent The work event that was in the queue to fire.

void WorkManager::HandleRepair	(	gemActor *	actor,
		Client *	client,
		const csString &	repairSlotName
	)		`[protected]`

This function handles commands like "/repair" using the following sequence of steps.

Make sure client isn't already busy digging, etc.
Check for repairable item in right hand slot
Check for required repair kit item in any inventory slot
Calculate time required for repair based on item and skill level
Calculate result after repair
Queue time event to trigger when repair is complete, if not canceled.
Parameters:

actor The actor that issues the command

client The client that issues the command, NULL if NPCClient

repairSlotName the slot name which should be repaired.

void WorkManager::HandleRepairEvent ( psWorkGameEvent * workEvent )

Handles a repair event, which occurs after a few seconds of repairing an item.

This function handles the conclusion timer of when a repair is completed. It is not called if the event is cancelled. It follows the following sequence of steps.

The values are all pre-calculated, so just adjust the quality of the item directly.
Consume the repair required item, if flagged to do so.
Notify the user.

Parameters:

workEvent The work event that was in the queue to fire.

void WorkManager::HandleUse ( Client * client )

Handles using an item for working.

This is called when an item is tagetted and the use command issued.

Parameters:

client The client that placed the item inside

void WorkManager::HandleWorkCommand	(	MsgEntry *	me,
		Client *	client
	)		`[protected]`

void WorkManager::HandleWorkEvent ( psWorkGameEvent * workEvent )

Handles a transformation/combination event.

Basically the manufacturing events.

Parameters:

workEvent The work event that was in the queue to fire.

void WorkManager::Initialize ( ) [protected]

bool WorkManager::IsContainerCombinable	(	uint32 &	resultId,
		int &	resultQty
	)		`[protected]`

Returns with the result ID and quantity of the combination if work item container has the correct items in the correct amounts.

Note:: This assumes that the combination items array is sorted by resultId and then itemId

Parameters:

resultId	The item ID of the resulting item.
resultQty	The stack quantity of the resulting item.

Returns:: False if combination is not possible.

bool WorkManager::IsHandCombinable	(	uint32 &	resultId,
		int &	resultQty
	)		`[protected]`

Returns with the result ID and quantity of the combination if player has the correct items in the correct amounts in hand.

Note:: This assumes that the combination items array is sorted by resultId and then itemId.

Parameters:

resultId	The item ID of the resulting item.
resultQty	The stack quantity of the resulting item.

Returns:: False if combination is not possible.

bool WorkManager::IsIngredient	(	uint32	patternId,
		uint32	targetId
	)		`[protected]`

bool WorkManager::IsOnHand ( uint32 equipId ) [protected]

unsigned int WorkManager::IsTransformable	(	uint32	patternId,
		uint32	targetId,
		int	targetQty
	)		`[protected]`

Check to see if there is a possible trasnform available.

Parameters:

patternId	The current pattern to use
targetId	the id of the item trying to transform.
targetQty	The stack count of the item to transform.

Returns:: An indicator of pattern match status.

bool WorkManager::LoadLocalVars	(	Client *	client,
		gemObject *	target = `NULL`
	)

Sets up the internal structure of the work manager to handle a particular client.

This sets many variables of the workmanager to work with a single user at a time.

Parameters:

client	The client that is the current one to use.
target	The object for which the client is targetting.

Returns:: False if there is a problem loading stuff.

void WorkManager::LockpickComplete ( psWorkGameEvent * workEvent )

bool WorkManager::MatchCombinations	(	csArray< psItem * >	itemArray,
		CombinationConstruction *	current,
		int &	multiplier
	)		`[protected]`

Returns true then item array matchs combination array regardless of order.

Parameters:

itemArray	The array of items that need to be checked.
current	The combination structure that includes an array of items
multiplier	this value will tell how many times this combination is run

Returns:: False if combination is not possible.

bool WorkManager::SameProductionPosition	(	gemActor *	actor,
		const csVector3 &	startPos
	)		`[protected]`

bool WorkManager::ScriptAction ( gemActionLocation * gemAction ) [protected]

bool WorkManager::ScriptActor ( gemActor * gemAct ) [protected]

bool WorkManager::ScriptItem ( gemItem * gemItm ) [protected]

bool WorkManager::ScriptNoTarget ( ) [protected]

void WorkManager::SendTransformError	(	uint32_t	clientNum,
		unsigned int	result,
		uint32	curItemId = `0`,
		int	CurItemQty = `0`
	)		`[protected]`

Sends an error message to the client based on the trade pattern error.

See also:: TradePatternMatch for the list of error conditions.

Parameters:

clientNum	the client to send the message to.
result	The error code from the transformable test.
curItemId	The current item ID.
CurItemQty	The current item quantity.

void WorkManager::StartAutoWork	(	Client *	client,
		gemContainer *	container,
		psItem *	autoItem,
		int	count
	)

Start a work event for this client.

This is called when an item is placed in a container. If the container is an auto-transform container it can transform items automatically ( ie placing items in automatically triggers the transformation process to start ).

Parameters:

client	The client that placed the item inside
container	The work item container that can transform an item.
autoItem	The item that was placed inside and to be transformed.
count	The stack count of the item placed in.

void WorkManager::StartCleanupEvent	(	int	transType,
		Client *	client,
		psItem *	item,
		gemActor *	worker
	)		`[protected]`

void WorkManager::StartCombineWork ( Client * client ) [protected]

Checks to see if the work container item can be used for combining.

Parameters:

client The client that issues the /combine command

void WorkManager::StartConstructWork ( Client * client ) [protected]

Checks to see if the item can be constructed.

Parameters:

client The client that issues the /construct command

void WorkManager::StartLockpick	(	Client *	client,
		psItem *	item
	)

Lockpicking.

bool WorkManager::StartScriptWork	(	Client *	client,
		gemObject *	target,
		csString	pattern
	)

Checks to see if the progression script generated craft work can be done.

Parameters:

client	The client for the actor that initiates that progressions script
target	Targetted item
pattern	Pattern name passed in progressions cript

Returns:: False if there is a problem doing the craft.

void WorkManager::StartTransformationEvent	(	int	transType,
		INVENTORY_SLOT_NUMBER	transSlot,
		int	resultQty,
		float	resultQuality,
		psItem *	autoItem
	)		`[protected]`

void WorkManager::StartUseWork ( Client * client ) [protected]

Checks to see if the item can be used for working.

Parameters:

client The client that issues the /use command

void WorkManager::StopAutoWork	(	Client *	client,
		psItem *	autoItem
	)		`[protected]`

Stop auto work event.

This is called when a client removes an item from any container before it has had a chance to transform the item.

Parameters:

client	The client that removed the item.
autoItem	The item that was being transformed.

void WorkManager::StopCleanupWork	(	Client *	client,
		psItem *	cleanItem
	)		`[protected]`

Handles stopping the cleanup event for a particular item.

This is called when an item is removed from a container.

Parameters:

client	The client that removes the item
cleanItem	The item that is removed

void WorkManager::StopCombineWork ( Client * client ) [protected]

Handles stopping the combining in the work container.

This is called when an item is tagetted and the /combine command issued and it's already in use.

Parameters:

client The client that issues the /combine command

void WorkManager::StopConstructWork ( Client * client ) [protected]

Handles stopping the constructing of an item.

This is called when an item is tagetted and the /construct command issued and it's already in use.

Parameters:

client The client that issues the /construct command

void WorkManager::StopUseWork	(	MsgEntry *	me,
		Client *	client
	)		`[protected]`

Handles stopping the use of the item for working.

This is called when an item is tagetted and the /use command issued and it's already in use.

Parameters:

me	The message entry.
client	The client that issues the /use command.

void WorkManager::StopWork	(	Client *	client,
		psItem *	item
	)

Stop work event.

This is called when a client removes an item from a container.

Parameters:

client	The client that removed the item.
item	The item that was being transformed.

psItem* WorkManager::TransformContainedItem	(	psItem *	oldItem,
		uint32	newId,
		int	newQty,
		float	itemQuality,
		psTradeProcesses *	process,
		psTradeTransformations *	trans
	)		`[protected]`

Parameters:

oldItem	The item which is going to be destructed (the old item).
newId	The id of the new.
newQty	The new number of items.
itemQuality	The new items quality.
process	The process which was applied in order to generate this item, if any, else NULL.
trans	The transformation which was applied in order to generate this item, if any, else NULL.

psItem* WorkManager::TransformSelfContainerItem	(	psItem *	oldItem,
		uint32	newId,
		int	newQty,
		float	itemQuality,
		psTradeProcesses *	process,
		psTradeTransformations *	trans
	)		`[protected]`

Parameters:

oldItem	The item which is going to be destructed (the old item).
newId	The id of the new.
newQty	The new number of items.
itemQuality	The new items quality.
process	The process which was applied in order to generate this item, if any, else NULL.
trans	The transformation which was applied in order to generate this item, if any, else NULL.

psItem* WorkManager::TransformSlotItem	(	INVENTORY_SLOT_NUMBER	slot,
		uint32	newId,
		int	newQty,
		float	itemQuality,
		psTradeProcesses *	process,
		psTradeTransformations *	trans
	)		`[protected]`

Parameters:

slot	The slot
newId	The new ID
newQty	The new number of items.
itemQuality	The new items quality.
process	The process which was applied in order to generate this item, if any, else NULL.
trans	The transformation which was applied in order to generate this item, if any, else NULL.

psItem* WorkManager::TransformTargetItem	(	psItem *	oldItem,
		uint32	newId,
		int	newQty,
		float	itemQuality,
		psTradeProcesses *	process,
		psTradeTransformations *	trans
	)		`[protected]`

Parameters:

oldItem	The item which is going to be destructed (the old item).
newId	The id of the new.
newQty	The new number of items.
itemQuality	The new items quality.
process	The process which was applied in order to generate this item, if any, else NULL.
trans	The transformation which was applied in order to generate this item, if any, else NULL.

void WorkManager::TransformTargetItemToNpc	(	psItem *	workItem,
		Client *	client
	)		`[protected]`

psItem* WorkManager::TransformTargetSlotItem	(	INVENTORY_SLOT_NUMBER	slot,
		uint32	newId,
		int	newQty,
		float	itemQuality,
		psTradeProcesses *	process,
		psTradeTransformations *	trans
	)		`[protected]`

Parameters:

slot	The slot
newId	The new ID
newQty	The new number of items.
itemQuality	The new items quality.
process	The process which was applied in order to generate this item, if any, else NULL.
trans	The transformation which was applied in order to generate this item, if any, else NULL.

bool WorkManager::ValidateCombination	(	csArray< psItem * >	itemArray,
		uint32 &	resultId,
		int &	resultQty
	)		`[protected]`

Returns with the result ID and quantity of the combination if the item list matches every item in a valid combination.

Parameters:

itemArray	The array of items that need to be checked.
resultId	The item ID of the resulting item.
resultQty	The stack quantity of the resulting item.

Returns:: False if combination is not possible.

bool WorkManager::ValidateConstraints	(	psTradeTransformations *	transCandidate,
		psTradeProcesses *	processCandidate
	)		`[protected]`

bool WorkManager::ValidateMind ( ) [protected]

bool WorkManager::ValidateNotOverSkilled	(	psTradeTransformations *	transCandidate,
		psTradeProcesses *	processCandidate
	)		`[protected]`

bool WorkManager::ValidateSkills	(	psTradeTransformations *	transCandidate,
		psTradeProcesses *	processCandidate
	)		`[protected]`

bool WorkManager::ValidateStamina ( Client * client ) [protected]

bool WorkManager::ValidateTarget ( Client * client ) [protected]

bool WorkManager::ValidateTraining	(	psTradeTransformations *	transCandidate,
		psTradeProcesses *	processCandidate
	)		`[protected]`

bool WorkManager::ValidateWork ( ) [protected]

Member Data Documentation

MathScript* WorkManager::calc_combine_quality [protected]

This is the calculation for the quality of combined work items.

Definition at line 340 of file workmanager.h.

MathScript* WorkManager::calc_lockpick_time [protected]

This is the calculation for how long it takes to pick a lock.

Definition at line 337 of file workmanager.h.

MathScript* WorkManager::calc_lockpicking_exp [protected]

This is the calculation for the experience to assign to player for lockpicking.

Definition at line 332 of file workmanager.h.

MathScript* WorkManager::calc_mining_chance [protected]

This is the calculation for chance of successful mining.

Definition at line 333 of file workmanager.h.

MathScript* WorkManager::calc_mining_exp [protected]

This is the calculation for the experience to assign to player for mining.

Definition at line 334 of file workmanager.h.

MathScript* WorkManager::calc_repair_exp [protected]

This is the calculation for the experience to assign to player for repairing.

Definition at line 331 of file workmanager.h.

MathScript* WorkManager::calc_repair_quality [protected]

This calculates the item ending quality and max quality at the end of repair.

Definition at line 330 of file workmanager.h.

MathScript* WorkManager::calc_repair_rank [protected]

This is the calculation for how much skill is required to repair.

Definition at line 327 of file workmanager.h.

MathScript* WorkManager::calc_repair_result [protected]

This is the calculation for how many points of quality are added in a repair.

Definition at line 329 of file workmanager.h.

MathScript* WorkManager::calc_repair_time [protected]

This is the calculation for how long a repair takes.

Definition at line 328 of file workmanager.h.

MathScript* WorkManager::calc_transform_apply_skill [protected]

This is the calculation for the quality resulting from the item.

Definition at line 338 of file workmanager.h.

MathScript* WorkManager::calc_transform_exp [protected]

This is the calculation for the experience to assign to player for trasformations.

Definition at line 335 of file workmanager.h.

MathScript* WorkManager::calc_transform_practice [protected]

This is the calculation for the practice to assign to player for trasformations.

Definition at line 336 of file workmanager.h.

MathScript* WorkManager::calc_transform_time [protected]

This is the calculation for the time needed to accomplish a transformation.

Definition at line 339 of file workmanager.h.

csPDelArray<NaturalResource> WorkManager::resources [protected]

list of all natural resources in game.

Definition at line 321 of file workmanager.h.

csStringArray WorkManager::resourcesActions [protected]

List of all actions usable with natural resources.

Note:: this must be never sorted in any way as it's cross referenced in resources so the array position of the string is extremely important to be mantained

Definition at line 326 of file workmanager.h.

The documentation for this class was generated from the following file:

server/workmanager.h

actor	The actor that issues the command
client	The client that issues the command, NULL if NPCClient
repairSlotName	the slot name which should be repaired.

WorkManager Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation