Tag List

This is a general listing of the tags used within GCA. This is pretty much just the basic listing, as I've not yet given tags the full documentation treatment.

I will be more fully explaining those tags that require it, including data templates and such, as time allows. If you need more info on a specific tag, please ask, and I'll try to update to include it.

There are a very large number of tags used in GCA. I have undoubtedly forgotten some. If you are looking for one that isn't listed here, please let me know.

Traits

Acc()
the accuracy value for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

Adds()
specifies traits that should be added to the character when the trait is added to the character.

AppPoints()
the applicable points available, from adding extrapoints() and multpoints().GCA calculates this.

ArmorDivisor()
this specifies the armor divisor for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

BaseCost()
the base cost (in $) of the item.

BasedOn()
specifies the trait upon which this one was based.

BaseLevel()
the base level of the trait, based on the points available from all sources (as found in appoints() ). GCA calculates this.

BasePoints()
the points actually spent by the user on this trait.

BaseScore()
this is the base value of the attribute, before any applicable bonuses are added. GCA calculates this.

BaseValue()
specifies the base value for the attribute. This may be a value, a calculation, or a simple reference. This base value is the "zero point" for the attribute, and levels up will increase the value from that point, while levels down will decrease the value from that point.

BaseWeight()
the base weight of the item.

BlockAt()
includes the template that tells GCA how the block score for this skill is calculated.

BlockLevel()
includes the level, based on blockat(), for blocking with the skill. GCA calculates this.

BonusLevels()
contains a value specifying the additional levels the user is adding directly to the trait as a bonus.

BonusList()
contains a list of all the bonuses and penalties being applied to the trait through all gives() statements that apply to this trait. GCA fills this.

BonusPoints()
any bonus points specified by the user.

Bulk()
includes the bulk value of the item.

CalcRange()
if it exists with a value, it forces GCA to calculate the range for the trait. This is useful in the rare cases where some sort of range may be needed, but the usual triggers for GCA to calculate range don't exist.

Cat()
this specifies the category, or categories, to which the trait belongs. This may be a comma separated list of category names, and the trait will be considered to belong to all specified categories.

CharAcc()
this is one of many "char" variants of other tags. This specifies the acc value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding acc() tag for the weapon or trait, but may not always be so.

CharArmorDivisor()
this is one of many "char" variants of other tags. This specifies the armor divisor value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding armordivisor() tag for the weapon or trait, but may not always be so.

CharDamage()
this is one of many "char" variants of other tags. This specifies the damage code specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding damage() tag for the weapon or trait, but may not always be so.

CharDamType()
this is one of many "char" variants of other tags. This specifies the damage type value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding damtype() tag for the weapon or trait, but may not always be so.

CharDB()
this is one of many "char" variants of other tags. This specifies the DB value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding db() tag for the weapon or trait, but may not always be so.

CharDR()
this is one of many "char" variants of other tags. This specifies the DR value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding dr() tag for the weapon or trait, but may not always be so.

CharParry()
this is one of many "char" variants of other tags. This specifies the parry notation specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding parry() tag for the weapon or trait, but may not always be so.

CharParryScore()
the character's parry skill score with this weapon or trait.

CharRadius()
this is one of many "char" variants of other tags. This specifies the radius of effect specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding radius() tag for the weapon or trait, but may not always be so.

CharRangeHalfDam()
this is one of many "char" variants of other tags. This specifies the half-damage range value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding rangehalfdam() tag for the weapon or trait, but may not always be so.

CharRangeMax()
this is one of many "char" variants of other tags. This specifies the maximum range range value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding rangemax() tag for the weapon or trait, but may not always be so.

CharRcl()
this is one of many "char" variants of other tags. This specifies the recoil value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding rcl() tag for the weapon or trait, but may not always be so.

CharReach()
this is one of many "char" variants of other tags. This specifies the reach value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding reach() tag for the weapon or trait, but may not always be so.

CharROF()
this is one of many "char" variants of other tags. This specifies the rate of fire value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding rof() tag for the weapon or trait, but may not always be so.

CharROF()
this is one of many "char" variants of other tags. This specifies the shots value specific to use by this character, including all the character specific bonuses and adjustments. In most cases, this will likely be the same as the corresponding shots() tag for the weapon or trait, but may not always be so.

CharSkillScore()
the final score or level of the attribute or skill being used for the weapon or trait is stored here. This may include any adjustments from targeted bonuses, or from inadequate ST.

CharSkillUsed()
based on skillused() for the weapon or trait, GCA finds the best choice for the character, and stores that attribute or skill name here.

ChildKeyList()
for parent-child relationships, this is the comma separated list of keys for all child items. GCA manages this, and users should not change it.

ChildPoints()
the total point value of all child items. GCA calculates this.

ChildrenCosts()
the cost (in $) of all child items. GCA calculates this.

ChildrenWeights()
the weight of all child items. GCA calculates this.

Conditional()
includes a list of conditional bonuses that the trait grants to other traits. Only bonuses or penalties that apply on a conditional bonus should be listed here, while bonuses or penalties that always apply should be listed in gives().

ConditionalList()
contains a list of all the conditional bonuses and penalties that can be applied to this trait, as a result of conditional() statements for other traits. GCA fills this.

Cost()
[Equipment] contains the cost (in $) of the item, including any adjustments made through modifiers, and any child items. GCA calculates this.

Cost()
[non-Equipment] contains a cost or cost list for the trait. Should be a single numeric value, or a list of numeric values separated by the "/" symbol. For example: cost(10) specifies a trait with a cost of 10 points, and cost(10/25/50) specifies a trait with at least three levels, the first of which costs 10 points, the second of which costs 25 points, and the third of which costs 50 points. Note that if a trait has a cost list, and the number of levels that may be purchased is limited, an upto() tag should also be used. Also note that GCA will use the difference in costs between the last cost specified, and the second to last cost specified, to price the cost of any levels not specified.

Count()
specifies the number of items this equipment trait represents.

Creates()
specifies traits that should be created from scratch, and then added to the character, when the trait is added to the character.

Damage()
this specifies the damage done by the trait. This is usually a simple GURPS style damage code, such as "sw+1" or "1d+3". Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

DamageBasedOn()
specifies the attribute or value that should be used for the basis of damage, rather than Striking ST. Basically, if some value is provided with this tag, the "sw" or "thr" code in the damage value will be replaced with the corresponding @sw or @thr function using the value provided.

DamType()
this specifies the type of damage, such as "sw" or "burn", for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

DB()
the defense bonus value for the item or trait.

Default()
specifies the other traits from which this one may default. This is a comma separated list of trait names and default values, and should include the prefix tag for each name specified. If a specified trait name includes math characters, then the name should be included in quotes. For example: default(IQ - 6, "SK:Artist (Calligraphy)" - 4, SK:Artist - 6)

DefFrom()
the skill or attribute being defaulted from, if any. GCA calculates this.

DefFromID()
the reference key for the deffrom() trait, if any. GCA sets this.

DefLevel()
the level received for this trait, by defaulting from the trait in deffrom().GCA calculates this.

DefPoints()
the point value equivalent for the deflevel().GCA calculates this.

Description()
a description of the trait.

DisplayCost()
a simple bit of text that GCA will display in the Cost column of the Available traits listing, instead of the cost() for the item. This allows for specifying a custom cost, or "varies" or any other short value that will provide more useful information to the user.

Down()
similar to the cost() tag, this specifies the costs for decreasing an attribute below the zero point. For example, lowering ST from 10 to 9 would use the cost specified in the down() tag for the ST attribute. As with cost(), this may be a list of values separated by the "/" symbol.

DownTo()
the value limiting the minimum level or points of the trait. Should contain a simple value, but may end with "pts" to specify that the value is a certain number of points. For example, downto(2) will limit the trait to 2 levels, while downto(2pts) will limit the trait to 2 points.

DR()
the damage resistance value for the item or trait.

ExtraLevels()
the total value of all applicable bonus levels, including syslevels() and any directly applied user added bonuses. GCA calculates this.

ExtraPoints()
the total of the bonuspoints() and syspoints(), and defpoints() if applicable. GCA calculates this.

Gives()
includes a list of bonuses that the trait grants to other traits. Only bonuses or penalties that should generally always apply should be included here, while bonuses or penalties that apply conditionally should be listed in conditional() instead.

GMS()
specifies whether the trait is to be listed on the GM Control Sheet. If the tag is gms(yes) then it should be included on the sheet.

Hide()
if hide(yes), then GCA will hide the trait from the listings, unless the user has set the trait list to show hidden traits.

Hides()
specifies if GCA should hide the traits that will be added or created as part of the template/meta-trait. If GCA sees "hides(yes)" then it will create those traits with "hide(yes)", otherwise it won't.

Keep()
lists the id key for the item that "owns" this one, as part of a template or meta-trait. GCA manages this, and users should not change it.

LC()
includes the lc value of the item.

Level()
the final level score for the trait, as calculated by GCA and shown to the user. GCA calculates this.

LevelMult()
the total value of all applicable level multipliers applied to the trait. GCA calculates this.

LevelNames()
specifies text names to use for the various levels of the trait, rather than simply listing the level number for the trait. This should be a comma separated list, so any of the level names that include a comma should be enclosed within quotes. For example: levelnames(1 person, 2-9 people, 10-99 people, 100-999 people, "1,000-9,999 people", "10,000-99,999 people") shows that level 1 of this trait has the name "1 person", while level 5 of this trait has the name "1,000-9,999 people". The default name for level 0 (a special case where the user has taken the item, but at no levels) is "none", but a different name can be specified by including it in the first position of the name list enclosed in brackets. For example: levelnames([None], Broken, Accented, Native)specifies that the zero level is "None" and the level 1 name is "Broken".

Load()
contains a comma separated listing of all the load-outs that the item is a part of.

Locked()
if any value is specified for locked(), then GCA considers the trait to be locked, and will not allow it to be edited.

Locks()
specifies if GCA should lock the traits that will be added or created as part of the template/meta-trait. If GCA sees "locks(yes)" then it will create those traits with "locked(yes)", otherwise it won't.

MainWin()
specific to attributes, this includes the position to display the attribute in the listing on the Normal View tab of the Attributes window.

MaxDam()
this specifies the maximum damage that can be done by the trait. This is usually a simple GURPS style damage code such as "1d+3". Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

MaxScore()
this is like upto(), and specifies the maximum score the attribute may have. This may be a value, a calculation, or a simple reference.

MinScore()
this is like downto(), and specifies the minimum score the attribute may have. This may be a value, a calculation, or a simple reference.

MinSTBasedOn()
weapons often have a minimum ST required. By setting this tag to a particular variant ST (Lifting ST, Striking ST, One-Arm ST, etc.), the weapon or trait can be customized to use the correct ST score for this particular weapon, when determining whether the minimum ST is met or not. This is important in those cases where GCA's calculated CharSkillScore is being penalized for inadequate ST, but your game or GM disagrees with GCA's interpretation. (GCA uses Lifting ST by default.)

Mode()
contains the names of the damage modes for the trait. If more than one mode exists, the names for each will be listed in this tag, separated by the "|" symbol.

Mods()
the list of modifier groups that are either particular to, or recommended for, this trait. This does *not* mean that other modifiers can't be applied, as there are a number of general modifiers that can be applied to a variety of traits, but aren't usually listed in their mods() tags.

MultPoints()
the calculated number of points for the trait, after any point multipliers have been applied to basepoints().GCA calculates this.

Name()
contains the name of the trait. Name() should not contain parenthesis, as those are used to denote the name extension.

NameExt()
contains the name extension of the trait, which is the bit displayed in parenthesis after the proper name of the trait.

Needs()
specifies the traits or conditions that are prerequisites for the trait.

NeedsCheck()
specifies whether the trait has passed its prerequisite check, based on specified needs() items. A value of "-1" means it has passed, while "0" means it has failed. GCA calculates this.

Notes()
notes for the trait.

OCount()
used to help track equipment trait counts, to avoid loops with items that have no cost or no weight. GCA manages this, and users shouldn't adjust it.

OptSpec()
the trait is an optional specialty if the trait has the optspec(1) tag. Changing optspec() to another value, or removing it, currently turns off optional specialty features. GCA manages this through the interface, so users generally shouldn't adjust this tag.

Owned()
specifies that the trait is owned by another trait. GCA manages this, and users shouldn't change the value of owned().

Owns()
specifies if the trait owns the traits that will be added or created as part of the template/meta-trait. If GCA sees "owns(yes)" then it will create those traits as child items, otherwise it won't.

ParentKey()
for parent-child relationships, this is the key for the parent trait. GCA manages this, and users should not change it.

Parry()
this specifies the parry notation, such as "No" or "0U", for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

ParryAt()
includes the template that tells GCA how the parry score for this skill is calculated.

ParryAtBonus()
includes any adder bonuses being targeted at parryat. GCA calculates this.

ParryAtMult()
includes any multiplier bonuses being targeted at parryat. GCA calculates this.

ParryLevel()
includes the level, based on parryat(), for parrying with the skill. GCA calculates this.

PKids()
contains a list of id keys for child items that the trait "owns". GCA manages this, and users shouldn't change the value of pkids().

PointMult()
the total value of all applicable point multipliers applied to the trait. GCA calculates this.

Points()
the displayed final points value for the trait, as shown to the user. GCA calculates this.

PreModsCost()
the total cost of the item, before any modifiers have been applied. GCA calculates this.

PreModsPoints()
the total point value of the trait, before any modifiers have been applied. This is generally basepoints() plus childpoints(), if applicable. GCA calculates this.

Radius()
this specifies the radius of effect for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

RangeHalfDam()
the half-damage range value for the weapon or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

RangeMax()
the maximum range value for the weapon or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

Rcl()
the recoil value for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

Reach()
the reach value for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

ROF()
the rate of fire value for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

Round()
this is a direction to GCA as to how it should round the calculated value of the attribute. This may be a calculation, but will generally be a simple numeric value: -1 means drop fractions, 1 means round 0.5 or more up to the next whole number, 0 means don't round at all.

Score()
this is the final score shown to the user. GCA calculates this.

SD()
specifies whether the trait is a "special default" item or not-basically whether it's a technique. A value of "1" means it's a technique, while a value of "0" means it's a standard skill. GCA will set this automatically, based on the skill type specified in type().

ShortLevelNames()
works just like levelnames(), but would include shorter name values for special cases where space is at a premium. If no shortlevelnames() tag is specified, the levelnames() tag values will be used instead, if available.

Shots()
the shots value for the item or trait. Note that if the weapon or trait has multiple modes, they will all be listed here, separated by the "|" symbol.

SkillUsed()
this lists the skill or skills available to be used for the weapon or trait. For example, Brass Knuckles can be used with Boxing, Brawling, Karate, or just plain default DX, so the tag would look like this: skillused(Boxing, Brawling, Karate, DX).

Step()
[attributes] specifies the amount by which each level of the attribute increases the attribute's score. For example, step(0.25) specifies that each level purchased increases the score by 0.25. If step() is "0" or not specified, no points may be spent on the attribute.

Step()
[skills] for use with relative levels, gives the amount by which the skill is over the related attribute or step-off point. GCA calculates this. GCA calculates this.

StepOff()
[skills] for use with relative levels, gives the related attribute or step-off point. GCA calculates this.

Symbol()
this is a special tag for attributes, providing for an abbreviated version of the trait name for use in calculations. (The symbol tag refers to the abbreviated name being a math symbol. In the interface, this is listed as Abbreviation on the Table View for attributes.)

SysLevels()
any bonus levels received from other traits, through gives() bonuses. GCA calculates this.

SysPoints()
any bonus points received from other traits, through gives() bonuses. GCA calculates this.

Taboo()
specifies the traits or conditions that are taboos for the trait.

TabooFailed()
specifies whether the trait has failed any taboos specified in the taboo() tag. A value of "-1" means that some taboo is being violated, while "0" means all is fine. GCA calculates this.

TabooText()
lists the taboos that the item has failed. GCA manages this.

TL()
the tech level of the trait. If specified, the tech level will be listed after the trait name, such as "/TL3", but before the name extension.

Type()
the skill type of the trait, such as "DX/H" or "IQ/E".

Up()
similar to the cost() tag, this specifies the costs for increasing an attribute above the zero point. For example, raising ST from 10 to 11 would use the cost specified in the up() tag for the ST attribute. As with cost(), this may be a list of values separated by the "/" symbol.

UpTo()
the value limiting the total level or points of the trait. Should contain a simple value, but may end with "pts" to specify that the value is a certain number of points. For example, upto(6) will limit the trait to six levels, while upto(6pts) will limit the trait to 6 points.

Weight()
the total weight of the item, for the count() of items, and adjusted by all child items. GCA calculates this.

X()
contains a variety of directives that GCA will operate on when the user adds this trait to the character.

Modifiers

BasedGroup()
the group of the modifier that this one was based on.

BasedOn()
the modifier that this one was based on.

ForceFormula()
when this tag exists with a non-empty value, it tells GCA to calculate the value of the modifier using the formula provided, regardless of the level of the modifier, or its apparent value.

Formula()
contains a formula to use to determine the value of the modifier.

Group()
the modifier group to which this modifier belongs. This is similar to cat() for traits, but each modifier can belong to only a single group().

Name()
the name of the modifier.

PreModsValue()
the value of this modifier, before any modifiers are applied.

Round()
Use round(up) to have the final value rounded up, or round(down) to have the final value rounded down.

ShortName()
a shorter version of the name, for use in most places where space is limited. (ShortName() is usually used in the list of modifiers being applied to traits, while the Name() is usually used to allow for selection of modifiers within the program.)

Tier()
the calculation level of the modifier. Tiers range from -2 to +2 (default is 0) and tell GCA what order the modifiers should be calculate it, when the order isn't standard. In most cases, you'll only need to use tier(1) to make sure that a particular modifier is applied after all other modifiers.

Value()
the value of the modifier, such as "+50%" or "-2".