Levelling Up Skills

Player Guide

This page is a player-created guide. Information may reflect personal opinions or playstyles; instruction snippets are examples only. See all guides for more advice.

IW's default skills system is a simple one where each character has a number of skills with scores from 0 (Incapable) to 5 (Exceptional). These skills are used to determine the outcome of the player's actions.

However, these skills and their values are fixed, no matter the events of the story. A player can practice a skill as much as they like, or even undergo events that should improve it (for example, magically gaining knowledge in a fantasy game), but the skill value remains unchanged. This can cause incongruities in the story, as the player will typically still fail attempts to use skills and knowledge that they ought to have.

Currently, there is no way to edit skills, even with Storyteller Mode, except through a trigger within the game. World creators may wish to consider triggers which improve skills, in order to allow characters to grow and develop.

It is also common to want to use some form of "experience" counter in order to track progression of a skill. A tracked item is ideal for this. Tell the tracked item to update whenever the player character uses or practices their skill, for example. Then, use trigger events to increase the skill value when the XP reaches a certain level. This requires a tracked item to store experience (likely one per skill, or one structured YAML tracked item) and one or more triggers per skill.

You may also wish to create a whole new skills system! This gives greater flexibility and actually makes the below examples easier since you can store the skill values in a tracked item which can be modified with pawscript scripts or even updated by the AI, rather than needing dedicated triggers.

Example: Skill XP with YAML TI

Here is an example using a single tracked item to store the XP for each skill.

First, we create a single YAML tracked item which lists the skills used in the game - let's call it "Skill XP":

Athletics: 0
Magic: 0
Basket-Weaving: 0

We use this tracked item's update instructions to tell the AI to increase the relevant value whenever the player uses the skill or practices/trains in it.

We decide we want skills to increase for every 10 points of XP, so for each skill we create a trigger which triggers when the relevant skill XP value is 10 or greater. For example, for Athletics we would check skill_xp.Athletics >= 10. The result of this trigger is to increase the skill's value by one point, but we also reduce the value by 10 so that we must gain more XP in order to increase the same skill again.

Naturally, more complex progressions are possible!

Dynamically Construct TI With PawScript

The above example is simple, but it requires writing out all the skills again! This is boring, and what if you later change your list of skills? You'll have to change this tracked item too! In order to avoid this very tiny amount of work, we can use a pregame trigger to set up this tracked item with a simple pawscript.

The list of player skills is available as $player.skills therefore a script such as the following will create our skill XP list for us:

$skill_xp = record()
for each $s in $player.skills.keys()
  $skill_xp.item($s) = 0

XP Earned This Turn

Better reliability may be gained by having a separate "XP gained" tracked item rather than having the AI modify the skill XP directly. This is more likely to be the case if implementing a custom skills system and perhaps storing more than just the XP in the tracked item. The AIs also seem to be less reliable at updating the correct elements in lists, rather than maps, if you choose to use such a construction, whereas writing a new "XP gained" list each turn should be easy.

In this case, use a trigger which fires each turn (or whenever the "XP gained" item has any values) and fires a script or series of effects so as to add the XP gained to the total, and then set the XP gained tracked item to be blank.

Don't sleep on Evaluation Instructions!

The "skill XP gained" concepts really benefits from the evaluation instructions being detailed and ideally explaining what a certain skill level actually is. This way the AI will check the player action against whatever metric makes sense for the world. It's also possible that not all skills can be leveled, and mentioning which ones CAN be leveled helps the AI along. Tests have also shown that it can handle vague descriptions like "Primary Power" with said power being mentioned in the character description as well (at least Lynx-Thinking can).

In general evaluation instructions are a very powerful tool. They make the rules if and when a skill is actually evaluated, has to be deemed a SUCCESS, PARTIAL_SUCCESS or FAILURE and what this actually looks like. And if you are building a leveling system for your skills, it is definitely important to nail down what they represent rather than just using the default instructions.

Evaluation Instructions can actually replace the skill system entirely if necessary. It's possible to hide the skills from players and have the evaluation based on all kinds of stuff. In the case of a leveling system this could mean a set of numeric tracked items that work like skills, but are not limited to five levels. Or have the AI evaluate agains the <skill_xp> tracked item directly (although with higher numbers that might be tricky). Alternatively a text tracked item to describe the player capabilities and have that be evaluated (a leveling system could update that tracked item to show the higher capabilities narratively instead of numerical).

Example: Level-Up System

An alternative approach: the player has a single "experience" value, and when it reaches a certain level, they "level up". At this point, they can choose a skill to improve! You may wish to track "level" too, but this is not necessary.

In order to manage the level up, you will need a tracked item for experience (with update instructions explaining to the AI when you should gain experience, and how much) and a trigger when it reaches a certain value - as in the previous example. This time, however, use the option to present a choice to the player. The choices must be listed one per line but we can use a pawscript expression. For example

<<$player.skills.where(value() < 5).keys().plain_list().title_case()>>

will take the list of skills which can still be increased (i.e. their value is < 5), take their names, put them into a list suitable for the "present a choice" trigger effect, and then apply .title_case() to make them look a bit nicer (they come out all in lower-case otherwise).

Put the chosen value in an other tracked item, and then use this tracked item to determine a set of triggers which actually increase the chosen skill.