Show the Derivation of Values (Savage) - Revision history

Rob: /* Showing Derivation for Character Creation Resources */

2009-02-11T07:07:43Z

Showing Derivation for Character Creation Resources

← Older revision		Revision as of 07:07, 11 February 2009
Line 270:		Line 270:
	</pre>		</pre>

	We must also identify any other places where the "resSpent" field is used directly. There happens to be one for handling the accrual of skill points, and it can be changed to use the new macro. The ~~new script~~ should look like below.		We must also identify any other places where the "resSpent" field is used directly. There happens to be one for handling the accrual of skill points, and it can be changed to use the new macro. The line of code that needs to be changes should look like below.

	<pre>		<pre>
	~~~if this skill is not added directly to the hero (i.e. an advance), skip it entirely~~		perform #resspent[resSkill,+,points,field[name].text]
	~~if (origin.ishero = 0) then~~
	~~done~~
	~~endif~~

	~~~the base value for skills is two, so we need to adjust by one to get the proper cost~~
	perform #resspent[resSkill,+,~~field[trtUser].value - 1~~,field[name].text]
	</pre>		</pre>

Rob at 06:47, 14 January 2009

2009-01-14T06:47:15Z

← Older revision		Revision as of 06:47, 14 January 2009
Line 282:		Line 282:
	</pre>		</pre>

	The final step is to display the history information via a MouseInfo script. Such a script is already in place within the "details" portal in the "baResource" template on the Basics tab. So all we need to do is change the script to return the appropriate information~~, which~~ amounts to the ~~line of~~ code below.		The final step is to display the history information via a MouseInfo script. Such a script is already in place within the "details" portal in the "baResource" template on the Basics tab. So all we need to do is change the script to return the appropriate information or a suitable message if there is nothing to report. This amounts to the code below.

	<pre>		<pre>
	@text = field[resSpent].history[", "]		@text = field[resSpent].history[", "]
			if (empty(@text) <> 0) then
			@text = "No Adjustments"
			endif
	</pre>		</pre>

Line 291:		Line 294:

	===Showing Derivation for Encumbrance and Load Limit===		===Showing Derivation for Encumbrance and Load Limit===

			As a side-effect of showing the derivation of character creation resources, we've gained the ability to display the derivation of encumbrance for the character. Both the tables on the Basics tab use the same template, which means both are now hooked up to show the history within the "resSpent" field. Since the accrual of encumbrance also uses the "#resspent" macro, we had to modify it during our conversion.

			The net result is that we can add some gear to a character and see the derivation without any further work. Move the mouse over the Encumbrance value shown and you should see a report of the items that contribute to the encumbrance rating for the character.

			The one drawback is that we also inherit this behavior for the Load Limit value. Since there is nothing spent for this resource, moving the mouse over the value shows a message "No Adjustments". That's not ideal, but it's not horrible either.

			If we really wanted to show something better for the Load Limit, we could do a lot of special handling. Alternately, we could get creative. If we setup a single adjustment using the "#resspent" macro for the resource, the text we use for the adjustment could be the text we want to show to the user via the MouseInfo script. Since we don't actually use the final value of the resource for anything, nor do we show it anywhere, spending the resource to add an entry to the history would work nicely.

			If you think of something useful to report for the load limit, feel free to give this tactic a try.

Rob at 06:24, 14 January 2009

2009-01-14T06:24:25Z

← Older revision		Revision as of 06:24, 14 January 2009
Line 252:		Line 252:
	<pre>		<pre>
	perform #resspent[resAttrib,+,field[trtUser].value - 2,field[name].text]		perform #resspent[resAttrib,+,field[trtUser].value - 2,field[name].text]
			</pre>

			These are all pretty simple to revise. The one that requires a little bit of thought is the handling of advances. For advances, we need to actually synthesize a truly useful name. If we simply use the type of the advance, then we'll end up with a bunch of vague references (e.g. "New Skill", "New Attribute", etc.). What we really need is both the type of advance and the details of the advance. This entails synthesizing an appropriate name, which yields a script that looks like the one below.

			<pre>
			var name as string
			name = field[advAction].text & ": " & gizmo.firstchild["Advance.Gizmo"].field[name].text
			perform #resspent[resAdvance,+,field[advCost].value,name]
	</pre>		</pre>

Line 274:		Line 282:
	</pre>		</pre>

			The final step is to display the history information via a MouseInfo script. Such a script is already in place within the "details" portal in the "baResource" template on the Basics tab. So all we need to do is change the script to return the appropriate information, which amounts to the line of code below.

			<pre>
			@text = field[resSpent].history[", "]
			</pre>

	~~In this instance~~, we ~~want to use~~ the ~~"changes" behavior for history tracking~~. ~~The reason~~ is ~~that every~~ attribute ~~will log~~ its consumption, including attributes that are at the minimum rating of "d4". ~~Since those~~ attributes ~~consume zero slots~~, ~~it doesn~~'t ~~make~~ any ~~sense to show~~ them ~~in the list~~. ~~By switching~~ to the "changes" ~~behavior~~, we'll only get adjustments that actually change something, so adjustments of zero will be automatically thrown out.		If we reload the data files and construct a character, we can move the mouse over the various character creation resource numbers and see a report of how those resources have been spent. However, there is a minor problem. Every attribute is logging its consumption, including attributes that are at the minimum rating of "d4" and consuming zero attribute points. Listing these attributes seems rather silly, since they don't provide any useful information for the user. Fortunately, we can easily omit them. If we go back to the "resSpent" field and modify the history tracking behavior to "changes", we'll only get adjustments that actually change something, so these adjustments of zero will be automatically thrown out.

	===Showing Derivation for Encumbrance and Load Limit===		===Showing Derivation for Encumbrance and Load Limit===

Rob at 06:08, 14 January 2009

2009-01-14T06:08:21Z

← Older revision		Revision as of 06:08, 14 January 2009
Line 215:		Line 215:
	===Showing Derivation for Character Creation Resources===		===Showing Derivation for Character Creation Resources===

			We can use the exact same process to accrue how the user has spent the initial character creation resources and display them on the Basics tab. All character creation resources are managed via the "Resource" component, with the "resSpent" field tracking the actual resources that are consumed. So we can institute history tracking for the "resSpent" field and log the selections made by the user for subsequent reporting.

			We start by modifying the field to enable history tracking, as shown below.

			<pre>
			<field
			id="resSpent"
			name="Quantity Spent"
			type="derived"
			history="stack">
			</field>
			</pre>

			After that, we can revise the "resspent" macro to apply tracked modifications.

			<pre>
			<scriptmacro
			name="resspent"
			param1="resource"
			param2="oper"
			param3="value"
			param4="text"
			result="hero.child[#resource].field[resSpent].modify[#oper,#value,#text]"/>
			</pre>

			We can now go through all instances where the "resspent" macro is used and convert them appropriately. In general, we'll want to specify the name of the edge, hindrance, or whatever as the source of the adjustment. For example, arcane powers each consume one slot via an Eval script, and that script gets revised to the version shown below.

			<pre>
			<eval index="2" phase="Setup" priority="5000"><![CDATA[
			perform #resspent[resPowers,+,1,field[name].text]
			]]></eval>
			</pre>

			Similarly, the accumulation of attribute points should be revised to look like the following.

			<pre>
			perform #resspent[resAttrib,+,field[trtUser].value - 2,field[name].text]
			</pre>

			There is one place where the "#resspent" macro is being used to retrieve the value and not modify it. In this instance, which deals with the load limit handling, we need to access the appropriate field value directly. The code below shows the old line and the new line that replaces it.

			<pre>
			spent = #resspent[resEncumb]

			spent = hero.child[resEncumb].field[resSpent].value
			</pre>

			We must also identify any other places where the "resSpent" field is used directly. There happens to be one for handling the accrual of skill points, and it can be changed to use the new macro. The new script should look like below.

			<pre>
			~if this skill is not added directly to the hero (i.e. an advance), skip it entirely
			if (origin.ishero = 0) then
			done
			endif

			~the base value for skills is two, so we need to adjust by one to get the proper cost
			perform #resspent[resSkill,+,field[trtUser].value - 1,field[name].text]
			</pre>



			In this instance, we want to use the "changes" behavior for history tracking. The reason is that every attribute will log its consumption, including attributes that are at the minimum rating of "d4". Since those attributes consume zero slots, it doesn't make any sense to show them in the list. By switching to the "changes" behavior, we'll only get adjustments that actually change something, so adjustments of zero will be automatically thrown out.

	===Showing Derivation for Encumbrance and Load Limit===		===Showing Derivation for Encumbrance and Load Limit===

Rob at 05:17, 14 January 2009

2009-01-14T05:17:30Z

← Older revision		Revision as of 05:17, 14 January 2009
Line 198:		Line 198:
	</pre>		</pre>

			We can now go through the data files and convert all uses of the "traitroll" and "traitprof" macros over to the new versions. The examples below show the properly revised Eval scripts for the "Ace" and "Strong Willed" edges.

			<pre>
			perform #traitprof[skBoating,+,2,"Ace"]
			perform #traitprof[skDriving,+,2,"Ace"]
			perform #traitprof[skPiloting,+,2,"Ace"]
			</pre>

			<pre>
			perform #traitroll[skIntimid,+,2,"Strong Willed"]
			perform #traitroll[skTaunt,+,2,"Strong Willed"]
			</pre>

			Don't forget that you'll also need to revise a few places where the "trtRoll" field is being used without the macro. These include the application of penalties for exceeding the load limit and the assignment of in-play adjustments. Once everything is switched over, you should be able to see all of the adjustment details by simply moving the mouse over the adjustment value within HL.

	===Showing Derivation for Character Creation Resources===		===Showing Derivation for Character Creation Resources===

Rob at 05:09, 14 January 2009

2009-01-14T05:09:48Z

← Older revision		Revision as of 05:09, 14 January 2009
Line 116:		Line 116:

	===Showing Derivation for Roll Adjustments===		===Showing Derivation for Roll Adjustments===

			The derivation history for roll adjustments on attributes and skills would also be extremely useful. Seeing a "+1" or "-2" next to an attribute or skill is helpful, but it's vastly more helpful to be able to quickly see what is causing that adjustment. We can utilize the same history mechanisms outlined above for this purpose as well.

			The calculation of the "trtNetRoll" field is based on three separate components. One of those is the impact of wounds and/or fatigue, so history tracking is not really applicable. However, the other two facets are the non-stacking adjustments due to professions and all the other stacking adjustments that can be accrued. Each of these is perfectly suited to history tracking.

			The first step is to change the two fields to utilize history tracking. The "trtRoll" field allows all the changes to be stacked, so we can institute "stack" history tracking, just like we did for the "trtBonus" field of derived traits. The "trtNoStack" field, though, does not support stacking. As such, we can utilize "best" history tracking to automatically identify only the biggest adjustment. After putting these changes into place, we should end up with revised field definitions like below.

			<pre>
			<field
			id="trtRoll"
			name="Bonus on Trait Rolls"
			type="derived"
			history="stack">
			</field>

			<field
			id="trtNoStack"
			name="Professional Trait Bonus"
			type="derived"
			history="best">
			</field>
			</pre>

			The next step is to setup appropriate macros to put the history mechanism to use for each field. We already have the "traitroll" and "traitprof" macros defined, so what we need to do is adapt them to use the history mechanism instead. This yields the revised macros shown below, which we'll then need to utilize differently throughout the data files.

			<pre>
			<scriptmacro
			name="traitroll"
			param1="trait"
			param2="oper"
			param3="value"
			param4="text"
			result="hero.childfound[#trait].field[trtRoll].modify[#oper,#value,#text]"/>

			<scriptmacro
			name="traitprof"
			param1="trait"
			param2="oper"
			param3="value"
			param4="text"
			result="hero.childfound[#trait].field[trtNoStack].modify[#oper,#value,#text]"/>
			</pre>

			Before we change all the field references to use the new macros, let's first look at how everything will be shown to the user. We need to display the derivation details in two separate places - for attributes on the Basics tab and for skills on the Skills tab. These involve two separate templates, but the logic we want will be the same for both. So we'll define a single procedure that can be used from both places and setup a MouseInfo script in each place to retrieve the information.

			The procedure needs to show all three facets of the derived value. So we'll setup the procedure to list each facet on a separate line, with the appropriate details for each being displayed. If there is nothing to report for a particular facet, we need to display that appropriately. Since the procedure will only be used from within a MouseInfo script, we can tailor it to directly generate the text to be displayed.

			The resulting procedure is shown below. Just below that, the MouseInfo script that should be added to the "adjust" portal within both templates is also presented. The MouseInfo script calls the procedure directly, relying on the procedure to put the proper information into the "@text" special symbol that will be displayed to the user.

			<pre>
			<procedure id="TrtDerive" scripttype="mouseinfo"><![CDATA[
			var info as string

			~start with the roll adjustments that stack
			info = field[trtRoll].history[", "]
			if (empty(info) <> 0) then
			info = chr(150)
			else
			info = signed(field[trtRoll].value) & ", " & info
			endif
			@text = "Stacking Adjustments: " & info & "{br}"

			~append the non-stacking professional adjustments
			info = field[trtNoStack].history
			if (empty(info) <> 0) then
			info = chr(150)
			else
			info &= " (" & signed(field[trtNoStack].value) & ")"
			endif
			@text &= "Professional Adjustments: " & info & "{br}"

			~append any penalties due to wounds or fatigue
			@text &= "Wound/Fatigue Penalties: " & signed(herofield[acNetPenal].value)
			]]></procedure>
			</pre>

			<pre>
			<mouseinfo mousepos="middle+above"><![CDATA[
			call TrtDerive
			]]></mouseinfo>
			</pre>

Rob at 01:54, 14 January 2009

2009-01-14T01:54:25Z

← Older revision		Revision as of 01:54, 14 January 2009
Line 9:		Line 9:
	The first thing we need to do is provide a place to accrue the derivation details for each trait. Your first thought is probably to define a new text-based field where this information can be tracked, and that approach would definitely work. However, the Kit provides built-in handling for just this type of situation.		The first thing we need to do is provide a place to accrue the derivation details for each trait. Your first thought is probably to define a new text-based field where this information can be tracked, and that approach would definitely work. However, the Kit provides built-in handling for just this type of situation.

	Fields that are value-based and derived can leverage history tracking that is wholly managed by HL. The tracking can take ~~two~~ different forms. The first is "best" tracking, which only tracks the largest adjustment applied to a given field and is ideally suited for situations where adjustments do not stack. The second is "stack" tracking, where each individual adjustment is tracked. ~~Obviously~~, we'll want to use the second form and present a report to the user that shows all of the adjustments that were applied.		Fields that are value-based and derived can leverage history tracking that is wholly managed by HL. The tracking can take three different forms. The first is "best" tracking, which only tracks the largest adjustment applied to a given field and is ideally suited for situations where adjustments do not stack. The second is "stack" tracking, where each individual adjustment is tracked. The third is "changes" and is identical to "stack", except that it automatically ignores any adjustments that have no net effect (e.g. adding zero). We'll want to use the second form and present a report to the user that shows all of the adjustments that were applied.

	We can enable history tracking very easily by adding a new attribute to the field definition. Since all of the adjustments we want to track are applied to the "trtBonus" field of Traits, we'll add history tracking to that field. The modified field definition should look similar to the one shown below.		We can enable history tracking very easily by adding a new attribute to the field definition. Since all of the adjustments we want to track are applied to the "trtBonus" field of Traits, we'll add history tracking to that field. The modified field definition should look similar to the one shown below.
Line 96:		Line 96:
	===Report the History for Derived Traits===		===Report the History for Derived Traits===

	The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". ~~Change~~ the script to report the adjustment history for the "trtBonus" field, ~~using~~ a ~~comma and space as the~~ separator between each entry. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.		The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???".

			We can change the script to report the adjustment history for the "trtBonus" field. This is achieved by using the "history" target reference on the field, specifying a suitable separator between each entry. We also want to be sure that the starting value is shown for each derived trait. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.

	<pre>		<pre>
Line 108:		Line 110:
	</label>		</label>
	<mouseinfo mousepos="middle+above"><![CDATA[		<mouseinfo mousepos="middle+above"><![CDATA[
	@text = field[trtBonus].history[", "]		@text = field[trtBonus].history[", ",start]
	]]></mouseinfo>		]]></mouseinfo>
	</portal>		</portal>

Rob at 00:08, 14 January 2009

2009-01-14T00:08:47Z

← Older revision		Revision as of 00:08, 14 January 2009
Line 94:		Line 94:
	Go through the data files and locate all instances where the derived traits are being modified. Every instance should be modified to use the new "#traitadjust" macro that logs what adjustment was applied. Be sure to also track the effects of equipped weapons and shields on the Parry trait, as well as the effects of equipped armor on the Toughness trait.		Go through the data files and locate all instances where the derived traits are being modified. Every instance should be modified to use the new "#traitadjust" macro that logs what adjustment was applied. Be sure to also track the effects of equipped weapons and shields on the Parry trait, as well as the effects of equipped armor on the Toughness trait.

	===~~Showing~~ the History ~~Report~~ for Derived Traits===		===Report the History for Derived Traits===

	The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". Change the script to report the adjustment history for the "trtBonus" field, using a comma and space as the separator between each entry. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.		The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". Change the script to report the adjustment history for the "trtBonus" field, using a comma and space as the separator between each entry. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.
Line 113:		Line 113:
	</pre>		</pre>

	===Showing Derivation for ~~Character Creation Resources~~===		===Showing Derivation for Roll Adjustments===


	===Showing Derivation for ~~Net Roll Adjustments~~===		===Showing Derivation for Character Creation Resources===


	===Showing Derivation for Encumbrance and Load Limit===		===Showing Derivation for Encumbrance and Load Limit===

Rob at 21:06, 13 January 2009

2009-01-13T21:06:02Z

← Older revision		Revision as of 21:06, 13 January 2009
Line 94:		Line 94:
	Go through the data files and locate all instances where the derived traits are being modified. Every instance should be modified to use the new "#traitadjust" macro that logs what adjustment was applied. Be sure to also track the effects of equipped weapons and shields on the Parry trait, as well as the effects of equipped armor on the Toughness trait.		Go through the data files and locate all instances where the derived traits are being modified. Every instance should be modified to use the new "#traitadjust" macro that logs what adjustment was applied. Be sure to also track the effects of equipped weapons and shields on the Parry trait, as well as the effects of equipped armor on the Toughness trait.

	===Showing the History Report===		===Showing the History Report for Derived Traits===

	~~use "history" target reference within MouseInfo script~~

	The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". Change the script to report the adjustment history for the "trtBonus" field, using a comma and space as the separator between each entry. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.		The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". Change the script to report the adjustment history for the "trtBonus" field, using a comma and space as the separator between each entry. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.
Line 114:		Line 112:
	</portal>		</portal>
	</pre>		</pre>

			===Showing Derivation for Character Creation Resources===


			===Showing Derivation for Net Roll Adjustments===


			===Showing Derivation for Encumbrance and Load Limit===

Rob at 21:03, 13 January 2009

2009-01-13T21:03:20Z

← Older revision		Revision as of 21:03, 13 January 2009
Line 82:		Line 82:
	</pre>		</pre>

	~~using macro everywhere with proper annotation instead of "traitderived"~~		We can now go through all the places in the data files where we modify the bonus for these four traits, converting each to apply the tracked adjustment. For example, within the "thing_edges.dat" file, the "Berserk" edge applies two separate adjustments to these traits. We need to change the penalty on the "trParry" trait to use the new adjustment macro and do the same for the bonus to the "trTough" trait. We can attribute both to the "Berserk" edge, yielding a new script that looks similar to the one below.






	~~The next step is to initialize~~ the ~~field to something appropriate~~ for each ~~derived trait. This is easily accomplished by defining~~ the ~~field value within each thing~~. For example, ~~we can set~~ the ~~initial derivation text for the Pace trait to something like~~ "~~Base of 6~~" ~~via~~ the "~~fieldval~~" ~~element, as shown below~~. ~~This should be done for all derived traits within~~ the ~~file~~ "~~thing_traits.dat~~".

	~~<pre>~~
	~~<fieldval field="trtDerived" value="Base of 6"/>~~
	~~</pre>~~

	~~Throughout~~ the ~~data files, there will be places where each derived field is modified in some way. In each of the locations, the derivation details must be logged at~~ the same ~~time~~ the ~~adjustment is applied. This is achieved by simply appending a suitable, brief description of~~ the ~~adjustment as text~~. ~~For example,~~ the "Berserk" edge ~~applies~~ a ~~+2 bonus to the character's Toughness and a -2 penalty to the character's Parry. Once the derivation details are added, the~~ new script ~~should look like~~ the one ~~shown~~ below.

	<pre>		<pre>
	if (field[abilActive].value = 0) then		if (field[abilActive].value = 0) then
	#~~traitbonus~~[trParry] -= 2		perform #traitadjust[trParry,-,2,"Berserk"]
	~~#traitderived[trParry] &=~~ ", Berserk -2"
	#traitroll[skFighting] += 2		#traitroll[skFighting] += 2
	#~~traitbonus~~[trTough] += 2		perform #traitadjust[trTough,+,2,"Berserk"]
	~~#traitderived[trTough] &=~~ ", Berserk +2"
	endif		endif
	</pre>		</pre>

	Go through the data files and locate all instances where the derived traits are modified. Every instance should be ~~accompanied by a corresponding~~ "#~~traitderived~~" macro that logs what adjustment was applied. Be sure to also track the effects of equipped weapons and shields on the Parry trait, as well as the effects of equipped armor on the Toughness trait.		Go through the data files and locate all instances where the derived traits are being modified. Every instance should be modified to use the new "#traitadjust" macro that logs what adjustment was applied. Be sure to also track the effects of equipped weapons and shields on the Parry trait, as well as the effects of equipped armor on the Toughness trait.

	For two of the derived traits, the final value depends on another trait that can also be modified by other effects. So we need to wait until the end of the evaluation cycle before applying the adjustment for the trait. This requires we define a new Eval script for each of the traits that properly appends the final adjustment description to the derivation field. The two traits that require this are the Parry and Toughness traits, which are based upon the Fighting skill and Vigor attribute, respectively. Putting it all together, the two Eval scripts below should handle things appropriately for these two traits.

	~~<pre>~~
	~~<eval index="2" phase="Render" priority="10000"><![CDATA[~~
	~~if (hero.childexists[skFighting] <> 0) then~~
	~~field[trtDerived].text &= ", Half Fighting +" & #trait[skFighting]~~
	~~endif~~
	~~]]></eval>~~

	~~<eval index="2" phase="Render" priority="10000"><![CDATA[~~
	~~field[trtDerived].text &= ", Half Vigor +" & #trait[attrVig]~~
	~~]]></eval>~~
	~~</pre>~~


	===Showing the History Report===		===Showing the History Report===
Line 128:		Line 98:
	use "history" target reference within MouseInfo script		use "history" target reference within MouseInfo script

			The derivation history should now be getting properly synthesized for each derived trait, so all we need to do now is make that history accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". Change the script to report the adjustment history for the "trtBonus" field, using a comma and space as the separator between each entry. The derivation details will now be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.


	The derivation ~~explanation~~ should now be getting properly synthesized for each trait, so all we need to do now is make it accessible to the user. Open the file "tab_basics.dat" and locate the "baTrtPick" template that is used to display the various derived traits. Within the template, the "details" portal shows the final value for the trait, and a MouseInfo script is defined that currently just outputs "???". Change the script to ~~return~~ the ~~contents of~~ the "~~trtDerived~~" field and the derivation details will be available to the user by simply moving the mouse over the value. The revised portal should look like the one shown below.

	<pre>		<pre>
Line 143:		Line 110:
	</label>		</label>
	<mouseinfo mousepos="middle+above"><![CDATA[		<mouseinfo mousepos="middle+above"><![CDATA[
	@text = field[~~trtDerived~~].~~text~~		@text = field[trtBonus].history[", "]
	]]></mouseinfo>		]]></mouseinfo>
	</portal>		</portal>
	</pre>		</pre>