This is the best way I found to formulate how I choose to write my code. Or maybe “Write the tools you need for code you want to read.”, or “write your code as a library”? I don’t know which on is better…

I will try to explain with an example.

The example

When you code you usually have a set of pre-existing tools (methods, classes, functions, …) that you can use to accomplish a task. Sometimes it comes from some kind of standard library, sometimes it comes from the code you already written and sometimes it comes from third-party library that you imported. Wherever these tools come from doesn’t really matter.

Let’s say you have a set of function at your disposal:

declare function querySelector(selector: string): HTMLElement | null;
declare function addEventListener<Evt>(eventName: string, callback: (e: Evt) => void): void;

interface UserConnectionStatusChangedEvent extends Event {
  status: "loggedin" | "loggedout";
}

So when smeone asks you hide or show/hide the #login-button and #logout-button when the event user-connection-status-changed is fired, you write:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
addEventListener("user-connection-status-changed", (e: UserConnectionStatusChangedEvent) => {
  const loginButton = querySelector("#login-button");
  const logoutButton = querySelector("#logout-button");
  if(loginButton == null || logoutButton == null) {
    console.error("Could not find login-button or logout-button");
    return;
  }
  if(e.status == "loggedin") {
    // hide the login button and show the logout button
    loginButton.style.display = "none";
    logoutButton.style.display = "inline";
  }
  else if(e.status == "loggedout") {
    // show the login button and hide the logout button
    loginButton.style.display = "inline";
    logoutButton.style.display = "none";
  }
});

This code works. But is it the code you would like to write? Is it the code you would like to read? What about:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
addEventListener("user-connection-status-changed", (e: UserConnectionStatusChangedEvent) => {
  const loginForm = new LoginForm("#login-form");
  loginForm.loginButton.setVisibility(e.status == "loggedin");
  loginForm.logoutButton.setVisibility(e.status == "loggedout");
});

// For which you would need to write the following tools:
class LoginForm {
  private element: HTMLElement;
  public constructor(selector: string) {
    const element = document.querySelector<HTMLElement>(selector);
    if(element == null) {
      throw new Error("Unrecoverable error: could not find login form in page");
    }
    this.element = element;
  }

  get loginButton() {
    return this.wrapElement(".login-btn");
  }

  get logoutButton() {
    return this.wrapElement(".logout-btn");
  }

  private wrapElement(selector: string) {
    const b = this.element.querySelector<HTMLElement>(selector);
    assert(b != null, "Could not find " + selector);
    return new HtmlElementWrapper(b);
  }
}

function assert(cond: boolean, message: string): asserts cond {
  if(cond == false) {
    throw new Error("Unrecoverable error: " + message);
  }
}

class HtmlElementWrapper {
  public constructor(private element: HTMLElement) { }
  public setVisibility(visibility: boolean) {
    if(visibility === true) {
      this.element.style.display = "inline";
    }
    else {
      this.element.style.display = "none";
    }
  }
}

In my opinion the second addEventListener call has a much lighter mental load. But I have to admit that the second solution need a lot of tools to work.

The first solution is 18 lines long and the second is 49 lines long. So from a line count point of view it becomes interesting as soon as we write the same kind of code three times.

Let’s say that later you have to hide the login button when in fullscreen mode, and when you preview a file. With the first solution you need to write 27 more lines:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
addEventListener("fullscreen", (e: any /* any for convenience, should be something like FullScreenEvent */) => {
  const loginButton = querySelector("#login-button");
  const logoutButton = querySelector("#logout-button");
  if(loginButton == null || logoutButton == null) {
    console.error("Could not find login-button or logout-button");
    return;
  }
  if(e.fullscreen == true) {
    loginButton.style.display = "none";
    logoutButton.style.display = "none";
  }
  else {
    loginButton.style.display = "inline";
    logoutButton.style.display = "inline";
  }
});

addEventListener("enter-file-preview", () => {
  const loginButton = querySelector("#login-button");
  const logoutButton = querySelector("#logout-button");
  if(loginButton == null || logoutButton == null) {
    console.error("Could not find login-button or logout-button");
    return;
  }
  loginButton.style.display = "none";
  logoutButton.style.display = "none";
});

With the second solution you would need to write 11 more lines:

1
2
3
4
5
6
7
8
9
10
11
addEventListener("fullscreen", (e: any) => {
  const loginForm = new LoginForm("#login-form");
  loginForm.loginButton.setVisibility(!e.fullscreen);
  loginForm.logoutButton.setVisibility(!e.fullscreen);
});

addEventListener("enter-file-preview", () => {
  const loginForm = new LoginForm("#login-form");
  loginForm.loginButton.setVisibility(false);
  loginForm.logoutButton.setVisibility(false);
});

But the second solution is also much more error resistant. You probably won’t make copy/paste mistakes for example. If you decide on a fallback method for when the buttons can’t be found you’ll just have to update it in one place. You could also imagining adding methods to the LoginForm and HtmlElementWrapper classes as your project grows.

Get on with it!

This kind of thinking is, I think, related to the DRY principle in the way that as soon as you start writing the code for the “fullscreen” event and “enter-file-preview” the second solution becomes kind of obviously better but as long as you limit yourself to the “user-connection-status-changed” it’s less straightforward.

So maybe we should talk about Anticipated-DRY? Because we want to write code like if you were going to repeat it even when you’re not (yet).

(Now that I have written this it would be fun to call this CRY for “Can’t Repeat Yourself”.)

Obviously, as with many things, this is not absolute, and sometimes repeating yourself is the way to go.

I’m not sure I was able to convey my point in this article. Maybe all of that is obvious. Maybe it’s just rambling.

Vancian Magic: a Bad History

A long time ago there was Vancian magic, it comes from some writer named Vance I think. Vancian spells are alive in the mind of the caster, they have to prepare each spell when they wake up. I read somewhere that the read the whole incatation except the last few words, the spell is almost finished, it’s just waiting for the last words to be released! These last words are the magical words that trigged the spell in battle (think “abrakadabra”). This vancian magic was used in older edition of D&D but it’s not anymore because it wasn’t flexible at all. You prepared exactly the spell you were going to cast so if you had 3 first level slots and 2 second level slot you may have prepared:

• 2 command spells
• 1 bless spell
• 1 spiritual weapon spell
• 1 lesser restoration spell

During the day if you realized that you didn’t need your spiritual weapon and would like to replace it with lesser restoration it wasn’t possible. I think they were some exception, like the Cleric was able to replace any vancianly prepared spell with a heal spell but the flexibility was very low.

Pseudo-Vancian Magic

In D&D5 they replace this with pseudo-vancian magic. The idea is that you have a pool of spell that you can pick from when you use a spell slot to cast a spell. The flexibility of this pool depend on your class.

Some classes learn new spells after certain events (usually when they level up) and their pool contains all the spell they know so they don’t need to prepare spells (alternatively you could say that they have all of their spells prepared all the time). The Bard, Sorcerer, Ranger, Rogue Arcane Trickster, Warlock works like this. They all have a “known spell” column in their table in the books. I call them school-of-life magicians.

Some classes know all of their spell from the start and their pool contains a subset of their choice that they can change after every long rest, that’s when they prepare their spells. The Cleric, Druid and Paladin work like this. I call them know-it-all magicians.

You will notice that Wizards are not mentionned, that’s because they are a weird case.

The case of the Wizard

The Wizard is a weird case. They learn new spell when they level up but also when they find scroll or spellbooks.

You might find other spells during your adventures. You could discover a spell recorded on a scroll in an evil wizard’s chest, for example, or in a dusty tome in an ancient library

Technically there is no “known spell” column in the PHB table but the text says (page 114):

At 1st level, you have a spellbook containing six 1st-level wizard spells of your choice.

and

Each time you gain a wizard level, you can add two wizard spells of your choice to your spellbook.

That means that even if wizards don’t automatically know all of their spell, they could learn a lot of them (and it’s the class that has access to the most spells) so for balance reason they can’t have “all of their spells prepared all the time”. That’s why they have to prepare a subset of their spells after every long rest.

In conclusion Wizard are hybrids. I call them learn-it-all.

Let’s say we have a database with articles and users. We want to write some function to get items from the database.

Let’s define what are articles an users first.

interface Article {
  title: string,
  content: string,
  date: number,
  hidden: boolean
  lang: "en" | "fr" | "es"
}

interface User {
  login: string,
  hashedPassword: string,
  salt: string,
  description: string,
}

Let’s create some users and articles.

const users: User[] = [
  { login: "Alice", hashedPassword: "a", salt: "ah", description: "Hi, I am Alice and this is my personal space." },
  { login: "Bob", hashedPassword: "b", salt: "bh", description: "Hello, I am Bob." },
  { login: "Carol", hashedPassword: "c", salt: "ch", description: "Hi, I am not Alice." },
];

const articles: Article[] = [
  { title: "Hello", content: "Goodbye.", date: 1, hidden: false, lang: "en" },
  { title: "Good morning", content: "Happy afternoon.", date: 2, hidden: true, lang: "en" },
  { title: "Hola", content: "¿Que tal?", date: 3, hidden: false, lang: "es" },
]

And let’s mix all of that in an array that will act as our database.

const actualDb: (User | Article)[] = [
  users[0], // 0: Alice
  articles[0], // 1: Hello
  users[1], // 2: Bob
  articles[2], // 3: Hola
  articles[1], // 4: Good morning
  users[2], // 5: Carol
]

Now we can write a function that gets an item from the database.

function getFromDb1(id: number) /* inferred return type is User | Article */ {
  return actualDb[id];
}

But what if there is no item in the database with the id we passed as a parameter? getFromDb1(42) would return undefined but the return type of the function doesn’t say undefined. There is two way to go about this.

1. Change TypeScript configuration to enable noUncheckedIndexedAccess which says to the compiler that every access to an array index could return undefined, it would make the return type of getFromDb1 inferred as User | Article | undefined. Technically, it is true that every indexed access to an array can return undefined but it may be quite cumbersome if generalized to the whole codebase, for example, if you enable it you’ll see that the declaration of actualDb has an error at every line.
2. Change the body of the function, see getFromDb2 below

function getFromDb2(id: number) /* inferred return type is User | Article | null */ {
  if (id >= actualDb.length) {
    return null; // we decide to return null instead of undefined here
  }
  return actualDb[id];
}

This is much better in my opinion since it actually forces us to check if the element is actually in the database.

let item1: User | Article = getFromDb2(2); // Good, the compiler give an error here "Type 'Article | User | null' is not assignable to type 'Article | User'. Type 'null' is not assignable to type 'Article | User'"
let item2: User | Article | null = getFromDb2(2); // This works, we explicitly says that item2 may be null
let item3 /* inferred type is User | Article | null */ = getFromDb2(2); // Obviously you don't need to explicitly write the type, TypeScript is able to perfectly infer it
let item4: User | Article = getFromDb1(2); // no error with the previous version, which is kind of dangerous because it can (and probably will at some point) return `undefined`

Get one item of a specific type

Now let’s say that you want to make a function to get a User by its id. You could do something like

function getUserById1(id: number) {
  return getFromDb2(id); // we use our best version of getFromDb
}

It would work as long as you’re passing an id that is from an actual User. But this function could also return a Article (the inferred return type of getUserById1 is User | Article | null), which is probably not what we want (it’s named “getUser” after all).

function getUserById2(id: number) /* inferred return type is User | null */ {
  const item = getFromDb2(id);
  if (item == null) {
    return null;
  }
  else if ("login" in item) {
    // Here TypeScript knows that item is a User because it has a login field, and between User and Article only User has a login field
    return item;
  }
  return null; // when item is not a User we return null, not much we can do here, the caller probably made a mistake, we could throw an exception but... (see after about exceptions)
}

Let’s do the same thing for Article.

function getArticleById2(id: number) /* inferred return type is Article | null */ {
  const item = getFromDb2(id);
  if (item == null) {
    return null;
  }
  else if ("title" in item) {
    return item;
  }
  return null;
}

Good. And now let’s say we want a function that can fetch any item from the database, check it it’s of the right type (User of Article) and actually return it only if it’s ok. Something like:

function getAnyItem(type: "article" | "user", id: number) /* inferred return type is User | Article | null */ {
  const item = getFromDb2(id);
  if (item == null) {
    return null;
  }
  else if (type == "article" && "title" in item) {
    return item;
  }
  else if (type == "user" && "login" in item) {
    return item;
  }
  else {
    return null;
  }
}

It looks good. Except that it’s not very practical to use.

function getIdFromUser() {
  // we use a random generator here but the idea is that the user is typing the id by hand so it could be anything
  return Math.round(Math.random() * 10); // a number between 0 and 9
}

let a /* inferred type is User | Article | null */ = getAnyItem("article", 1); // will return article Hello
let b /* inferred type is User | Article | null */ = getAnyItem("user", 0); // will return user Alice
let c /* inferred type is User | Article | null */ = getAnyItem("article", getIdFromUser()); // will return one of the article or null
let d /* inferred type is User | Article | null */ = getAnyItem("user", getIdFromUser()); // will return one of the user or null

We KNOW that c will be NOT be of type User. It can’t because if it’s something else the check type == "user" && "login" in item will be false and the function will return null.

In the same way we KNOW that d CANNOT BE of type Article.

Never the less the types of c and d are User | Article | null. It would be nice if because of the first parameter being “article” we were able to tell TypeScript that the return type was going to be an Article. Same thing when the first parameter is “user”.

Enter mapped types!

Mapped Types

interface DbObjectMapping {
  "article": Article,
  "user": User,
}

function getAnyItem2<T extends keyof DbObjectMapping>(type: T, id: number): DbObjectMapping[T] | null {
  // let's leave the body empty for now
  return null!; // just a hack to remove the warning from the TypeScript compiler, ignore it
}

A few explanations are probably necessary. First what does keyof DbObjectMapping means?

let e: keyof DbObjectMapping = "article"; // ok
e = "user"; // ok
e = "hello"; // error: Type '"hello"' is not assignable to type 'keyof DbObjectMapping'.

So keyof DbObjectMapping is basically "article" | "user", the possible values that the keys of DbObjectMapping could have. The keys are the named to the left of the “:” in DbObjectMapping.

Second, what does T extends keyof DbObjectMapping means? It means that we declare a type variable called T that must be of type keyof DbObjectMapping so either “article” or “user”. The type parameter must be of this type so it can only be “article” or “user”.

Third, what about DbObjectMapping[T]? Well now that we know that T is "article" | "user" it quite obvious. DbObjectMapping[T] will be User when T is "user" and Article when T is "article".

Let’s see how we can use that.

// reminder: [0: Alice, 1: Hello, 2: Bob, 3: Hola, 4: Good morning, 5: Carol]
let u1 /* inferred type is User | null */ = getAnyItem2<"user">("user", 0); // should return user Alice
let a1 /* inferred type is Article | null */ = getAnyItem2<"article">("article", 1); // should return article Hello
let a2 /* inferred type is Article | null */ = getAnyItem2<"article">("article", 2); // should return null since the id with id 2 is a User and we are asking for an Article

“But we are just writing “user” twice!? What’s the point?!” you may ask. And you are right. luckily for us, TypeScript is smart, you can just remove the first instance and it will deduce that since the parameter type is “user” (or “article”) then T must be “user” (or “article”).

let u3 /* inferred type is User | null */ = getAnyItem2("user", 0); // the type is inferred as getAnyItem2<"user">(type: "user", id: number): User | null
let a3 /* inferred type is Article | null */ = getAnyItem2("article", 1); // the type is inferred as getAnyItem2<"article">(type: "article", id: number): Article | null

Now let’s try to write the body of our function.

function getAnyItem3<T extends keyof DbObjectMapping>(type: T, id: number): DbObjectMapping[T] | null {
  const item = getFromDb2(id);
  if(item == null) {
    // No item with this id has been found
    return null;
  }
  else if (type == "article" && "title" in item) {
    // TypeScript knows that item is an Article here
    return item;
    /*
    We have an error here:
    Type 'Article' is not assignable to type 'DbObjectMapping[T]'.
      Type 'Article' is not assignable to type 'Article & User'.
        Type 'Article' is missing the following properties from type 'User': login, hashedPassword, salt, description
    */
  }
  else if (type == "user" && "login" in item) {
    // TypeScript knows that item is an User here
    return item;
    /*
    Error:
    Type 'User' is not assignable to type 'DbObjectMapping[T]'.
      Type 'User' is not assignable to type 'Article & User'.
        Type 'User' is missing the following properties from type 'Article': title, content, date, hidden, lang
    */
  }
  else {
    // the type parameter does not match the actual type of the item
    return null;
  }
}

We have errors here. Weird errors. And sadly I don’t know any clean way of fixing it. What happens is that TypeScript knows that DbObjectMapping[T] can be an Article or a User and understands it as the fusion of the two, as an objects with the field of BOTH. You can be sure of this because the following code does not give any error.

function getAnyItem4<T extends keyof DbObjectMapping>(type: T, id: number): DbObjectMapping[T] | null {
  return {
    // field from Article
    title: "Hello",
    content: "Goodbye.",
    date: 1,
    hidden: false,
    lang: "en",
    // fields from User
    login: "Alice",
    hashedPassword: "a",
    salt: "ah",
    description: "Hi, I am Alice and this is my personal space.", // if we remove this line there will be an error: Property 'description' is missing in type
  }
}

You can check this Stack Overflow thread for an other explanation.

We can “fix” the function this way:

function getAnyItem5<T extends keyof DbObjectMapping>(type: T, id: number): DbObjectMapping[T] | null {
  const item = getFromDb2(id);
  if(item == null) {
    return null;
  }
  else if (type == "article" && "title" in item) {
    return item as DbObjectMapping[T]; // we basically say to TypeScript to ignore the error because we know what we are doing
  }
  else if (type == "user" && "login" in item) {
    return item as DbObjectMapping[T]; // we basically say to TypeScript to ignore the error because we know what we are doing
  }
  else {
    return null;
  }
}

And since we are doing the same thing when type == "article" && "title" in item and when type == "user" && "login" in item we can simplify the function to:

function getAnyItem6<T extends keyof DbObjectMapping>(type: T, id: number): DbObjectMapping[T] | null {
  const item = getFromDb2(id);
  if(item == null) {
    return null;
  }
  // we merge the two conditions here
  else if ((type == "article" && "title" in item) || (type == "user" && "login" in item)) {
    return item as DbObjectMapping[T];
  }
  else {
    return null;
  }
}

Not really satisfying if you ask me but I don’t know any other way to do it.

Why Not Use Exceptions?

When we wrote getUserById2 (duplicated below as getUserById22) I said that instead of returning null we could theoratically throw an exception but… and I didn’t explain why. Well it’s simple. There is no way in TypeScript to specify which exception a function might throw, which means that you can’t statically enforce catching them and I don’t like that.

function getUserById22(id: number) /* inferred return type is User | null */ {
  const item = getFromDb2(id);
  if (item == null) {
    return null;
  }
  else if ("login" in item) {
    // Here TypeScript knows that item is a User because it has a login field, and between User and Article only User has a login field
    return item;
  }
  return null; // when item is not a User we return null, not much we can do here, the caller probably made a mistake, we could throw an exception but... (see after about exceptions)
}

So if instead we threw an exception we would have something like;

class ItemNotFound extends Error {};
class ItemOfWrongType extends Error {};

function getUserById23(id: number) /* inferred return type is User */ {
  const item = getFromDb2(id);
  if (item == null) {
    throw new ItemNotFound();
  }
  else if ("login" in item) {
    // Here TypeScript knows that item is a User because it has a login field, and between User and Article only User has a login field
    return item;
  }
  throw new ItemOfWrongType();
}

Notice how the return type is now just User instead of User | null. For the caller it looks like the call can’t fail. We can write:

{
let u = getUserById23(1); // it will throw an ItemOfWrongType exception since the item of id 1 is an Article
console.log(u.login); // no error from the compiler, which make sense if you think about it, we will never reach this line since the previous line will throw an exception
let u2 = getUserById23(42); // it will throw an ItemNotFound exception since there is no item with and id of 42
console.log(u2.login);
}

Those call will fail and the compiler doesn’t warn us. With the previous version it would have said something:

{
let u = getUserById22(1);
console.log(u.login); // with getUserById22 the compiler is able to warn us than u may be null
let u2 = getUserById22(42);
console.log(u2.login); // same for u2
}

TypeScript could support some syntax to declare which exception a function can throw and force the caller to catch it. Like so (this syntax is NOT valid):

function getUserById24(id: number) /* throws ItemNotFound, ItemOfWrongType */ {
  const item = getFromDb2(id);
  if (item == null) {
    throw new ItemNotFound();
  }
  else if ("login" in item) {
    // Here TypeScript knows that item is a User because it has a login field, and between User and Article only User has a login field
    return item;
  }
  throw new ItemOfWrongType();
}

{
let u = getUserById24(1); // and here we could have a compiler error saying something like "getUserById24 can throw ItemNotFound or ItemOfWrongType but they aren't catched"
console.log(u.login);
}

But TypeScript doesn’t support that. And it’s not in the cards.

The good news is that you can still use Either types or declare the function like this function getUserById24(id: number) : ItemNotFound | ItemOfWrongType | User and check the return type with instanceof Error.

Let’s start with a simple example.

let stringValue: string = "abcString";
let stringAsAny: any = "abcAny;"

stringValue.charAt(3); // will return "S"
stringAsAny.charAt(3); // will return "S", the same thing since stringAsAny is actually a string
stringValue.endsWith("g"); // will return true
stringAsAny.endsWith("g"); // will return true, the same thing since stringAsAny is actually a string

And we have the same thing for every methods or function that exists on or takes as string. Things change when we make a mistake.

let numberValue: number = 3;
numberValue.toExponential(2); // will return "3.00e+0" because toExponential gives the exponential notation of the number, obviously this makes sense only for number
stringValue.toExponential(2); // so it makes sense that this is a compiler error since toExponential is NOT a string method
stringAsAny.toExponential(2); // but this is not a compiler error, because any means "I know what I'm doing" (aka JS mode) to the compiler, it will still fail at runtime though

Sometimes we use any without noticing (linters are useful for this).

let a; // a is implicitly any
a = 3; // but TypeScript is smart so from now on a will be typed as number
a.toExponential(2); // no error, as intended
a.charAt(2); // typescript detects the error

a = "hello"; // 
a.toExponential(2); // typescript detects the error
a.charAt(2); // no error

In this cas it would have been better to declare a as number | string, like this:

let aa: number | string = 3; // TypeScript is too smart for us here and it breaks the example I wanted to make. We declare aa as `number | string` but it detects that we affect it a number so it is a number.
aa.toExponential(2); // that's why this works
aa.charAt(2); // but this doesn't
aa.toString(); // and this would work in any case since toString exists both on number AND string

Return a disjunctive type

So, let’s redo out example but with a function:

function numberOrString(): string | number {
  if(Math.random() > 0.5) {
    return "a";
  }
  else {
    return 3;
  }
}

You can try to remove the return type string | number and you’ll notice that TypeScript inferred the returned type to "a" | 3 which is true but too specific for our example so I put the return type myself and since string | number is compatible with "a" | 3 it works. Putting just “number” as the return type would have been a compiler error when we try to return "a".

Anyway, we now have a function that returns sometimes a number and sometimes a string, and we have no way to know in advance which, it is perfect for our example!

This example is a little contrived, but you can imagine that you get records from an API and the API sometimes return a number and sometimes a string.

let aaa = numberOrString(); // type of aaa is "number | string", good!
aaa.toExponential(2); // compiler error
aaa.charAt(2); // compiler error
aaa.toString(); // works

It’s a little weird that both toExponential and charAt gives a compiler error but since we don’t know if it’s a number or a string we can’t actually call any of those methods until we are sure of the type. Calling toString is fine since it exists on both type anyway.

if(typeof(aaa) == "string") {
  aaa.charAt(2); // in this branch typescript knows that aaa is a string because of the test
  aaa.toExponential(2); // and it also knows that it's NOT a number so this is a error
}
else {
  aaa.toExponential(2); // in this branch TypeScript knows that aaa is NOT a string, which means that it's a number since there is only 2 possibilities
}

If there were 3 possible return types:

function numberOrStringOrBoolean(): string | number | boolean {
  const rand = Math.random();
  if(rand < 0.3) {
    return "a";
  }
  else if(rand < 0.6) {
    return true;
  }
  else {
    return 3;
  }
}

let aaaa = numberOrStringOrBoolean();
if(typeof(aaaa) == "string") {
  aaaa.charAt(2); // in this branch typescript knows that aaaa is a string because of the test
  aaaa.toExponential(2); // and it also knows that it's NOT a number so this is a error
}
else {
  // and here aaaa is either a boolean OR a number
  let a = aaaa; // check the type of a by hovering over it
  if(typeof(aaaa) == "boolean") {
    // the compiler knows that aaaa is a boolean here
    aaaa;
  }
  else {
    aaaa;
  }
}

// obviously in a real example we would have just done
if(typeof(aaaa) == "string") {
  aaaa.charAt(2); // in this branch typescript knows that aaaa is a string because of the test
  aaaa.toExponential(2); // and it also knows that it's NOT a number so this is a error
}
else if (typeof(aaaa) == "boolean") {
  // the compiler knows that aaaa is a boolean here
  aaaa;
}
else {
  // the compiler knows that aaaa is a number here
  aaaa;
}

We showed that it’s better to use disjunctive types (“disjunction” means “or” and is represented in TypeScript by the character “|” like in number | string | boolean which means “number or string or boolean”)

We got a little off track here, we wanted to talk about the any type so let’s go back to it.

Using a Library

Most of the times when I am forced to use any it’s because I use a library that uses it. Usually the library could have avoided using it by make better typings but… we are stuck with it, let’s see how to get out of this problem to avoid the stringAsAny.toExponential(2) fiasco.

Let’s say we have a lib called SomeLib with a method getSomething which return an any

function getSomethingOld(): any {
  return numberOrStringOrBoolean(); // the library authors could have put "number | string | boolean" as the return type here, but it could also have been much more compilcated, it's probably much more complicated and that is why they used any
}

const SomeLib = {
  getSomething: getSomethingOld
}

let somethingNew = SomeLib.getSomething(); // no surprise here somethingNew is of type any

The problem with any values is that TypeScript is VERY permissive with them which means that you can do.

let somethingBorrowed: number = SomeLib.getSomething(); // no error here. any means "I know what I am doing" so TypeScript suppose that you know what you are doing. TypeScript is wrong here, you made a mistake but you told it you knew what you were doing, what's it supposed to do?

// The mistake could be more subtle
function addThree(n: number) {
  return n + 3;
}

addThree(SomeLib.getSomething()); // will return "a3" ("a" + 3), or 4 (true + 3, true is 1 in sums, don't get me started...), or 6 (3 + 3), which is probably not what we want, we would have liked if typescript said something like "This function expects a number here but you gave any which may or may not be a number", but that would contradict the "I know what I am doing" mantra so it justs stay silent

// to be safe you would have to do
if(typeof(somethingNew) == "number") {
  addThree(somethingNew); // in this branch somethingNew is of type number so it will always do what's reasonnable (adding number between them and NOT adding number and a string or a number and a boolean)
}

But TypeScript won’t say anything if you forget to check the type because any means “I know what I am doing”, which we sometime are… but not always

Lucky for use our savior is here and it is unknown!

function getSomethingBlue(): unknown {
  return numberOrStringOrBoolean();
}

// Let's redo our lib
const SomeBetterLib = {
  getSomething: getSomethingBlue
}

let somethingNew2 = SomeBetterLib.getSomething(); // somethingNew is of type unknown, but what does it mean?
let somethingBorrowed2: number = SomeBetterLib.getSomething(); // it means you can't do that, compiler error!
addThree(SomeBetterLib.getSomething()); // and that you can't do that either, compiler error again!

Actually you can’t do anything with an unknown! That’s the beauty of it. It seems kind of useless right? You’re right. Until you use the “as” operator.

let somethingBorrowed3: number = SomeBetterLib.getSomething() as number; // no compiler error but is it really what we want? We know that getSomething could also return a boolean or a string...
addThree(SomeBetterLib.getSomething() as number); // no error here, but we could be adding boolean and number so shouldn't there be an error?

Well, “as” is basically an other way to say “I know what I’m doing”, actually it’s a way to say “I mostly know what I’m doing” (note the “mostly”) because there is some checks done, we’ll get to those later.

The good thing with unknown, and why it’s better than any, is that we can’t forget about it, we have to explicitly “cast” (not really a cast, it’s a “type assertion”, we’ll see about that later) it.

To avoid using “as” everytime I use SomeBetterLib.getSomething() I can either wrap it into a function of my own or redo the types of the library (which is basically similar to wrapping it since I just use the types of the wrapping function at the declaration site).

function getSomethingWrapped() {
  return SomeBetterLib.getSomething() as number | boolean | string; // to deduce this type I had to look at the code or test it multiple times
}

Now I can use getSomethingWrapped without using any type assertions (“cast”).

So, to sum up: never use any. Use unkown instead.

Even the standard library makes this mistakes with JSON.parse()

let j = JSON.parse("{}"); // j is any here which means I can do
j.lol();
j.hello(); // without error, here the example si simple enough and we know it will fail at runtime but if JSON.parse() returned unknown we could not do this.

function JsonParseWrapped(jsonString: string) {
  return JSON.parse(jsonString) as unknown;
}
let jj = JsonParseWrapped("{}"); // j is any here which means I can do
jj.lol(); // error
jj.hello(); // error
(jj as number).toExponential(2); // works for the compiler but will obviously fail at runtime

The TypesSript “as” operator

Now let’s talk about “as”. You probably know that TypeScript is compiled (or transpiled) to JavaScript. You probably know that most of what makes TypeScript is stripped away during this transpilation step which means that, at runtime, TypeScript DOES NOT exists. The “as” operator doesn’t exists in JavaScript, it’s only a TypeScript notion. You can verify it easily.

(jj as number).toExponential(2); // TypeScript code
jj.toExponential(2); // transpiled JavaScript code of the previous line, "as" is nowhere to be seen
// That's why I said that "as" is like saying to the TypeScript compiler "I mostly know what I'm doing", why mostly? There is some checks done.

type X = { x: string; }
type Y = { y: number; }
let x: X = { x: "a" };
let y = x as Y; // we have an error here "Conversion of type 'X' to type 'Y' may be a mistake because neither type sufficiently overlaps [...]", basically TypeScript it telling that X and Y have nothing in common so it may be a mistake
let yy = x as unknown as Y; // but this does not give a compile error, it will still give a runtime error when you try to access yy.a.charAt but at least you have to really want it!

type Z = { x: string; z: boolean; }
let z = x as Z; // but here it's ok because X and Z have some fields in common, it will still fail at runtime though

But again, this is “as” only exists at compile time which means that if you make a wrong type assertion it will fail at runtime

Checking that you can safely convert a type into another is a complicated problem in the scope of data validation or input validation which I haven’t explored enough to talk about. ```

I want to get the some of the feeling of spells, choose amongst a wide variety of options, do something different gameplay-wise, do something amazing! But I don’t want it to feel like an other list of spells and using spell slots. And I want to especially improve out-of-combat game (exploration and social interaction), not combat, combat is fine.

So I started working on this and it was kind of lost in development hell. More recently there was some talk on reddit about martial power disparity and the fact that martials need their own resources similar to spell slots. The concept of heroic actions was already written so I thought I should push through! And here it is.

I asked myself: what are fighters meant to be? Heroes. And what do heroes do?

• Ulysses deceives a Cyclop
• Indiana Jones escapes a rolling boulder and punch Hitler
• Aragorn fights a troll and inspire its troops at the gate of Mordor
• Luke Skywalker shot amazingly into the exhaust vent which lead to the Death Star exploding
• Maximus gains the love of the crowd

They do that and many other amazing feats. But they mostly do each feat once. And that is the idea. A list of Heroic Actions that can only be accomplished once by a character. When it’s done, it’s done and it will never happen again.

So let me introduce …

The Chapter of Heroes

Writers will blacken pages with your stories. Philosophers will analyze your actions. Bards will sing your adventures in taverns around the world. History will be studied through the prism of your fights and speeches. But doomed you will be since nobody remembers second times.

If you’re a fighter, barbarian or monk you get access to heroic actions. You heroic rank is equal to your level in the sum of those classes an determines how many heroic actions you have access to. If you gain one level in any other class you loose the ability to gain new heroic actions.

Most heroic action can be used whenever you want without consuming any action or bonus action, there is no limit to the number of heroic action you can use during your turn but be mindful because you can only use each heroic action once. Not once per day, not once per long rest, not once per short rest, once.

When you reach heroic rank one you choose your first 5 heroic actions and you gain all the tier 0 heroic actions. Every time your heroic rank increases you gain access to two more heroic actions.

If your heroic rank is less than 4 you only have access to tier 1 heroic actions. When you reach an heroic rank of 5 you gain access to tier 2 heroic actions. At heroic rank 11 you gain access to tier 3 heroic actions.

Every time you use an heroic action you loose it. People will chant about your exploits but you will never be able to use it again. The next time you gain a level you automatically learn the echoed version of this heroic action which can also be used once.

Some of your heroic actions require your target to make a saving throw to resist the effects. The saving throw DC is calculated as follows: 8 + your proficiency bonus + your Strength modifier.

Heroic Actions (44)

Tier 0 (1)

Generic Heroic Actions (1)

1. I know. You can learn any heroic action (that you never learned and never used).
   • Echoed: During a short rest, you can spend some time remembering your old adventures and learn any heroic action (that you never learned and never used).

Tier 1 (25)

Tactical Heroic Actions (11)

1. I see you. You can throw any weapon as if it had the thrown property with a range of 200 ft/600 ft.
   • Echoed: You can throw a weapon with the thrown property as if it had the thrown property with a range of 200 ft/600 ft.
2. I can’t Hear You. You smash your head and ears, you are immune to any effect that would sense your emotions or read your thoughts and the charmed condition for the next minute.
   • Echoed: As an action you smash your head and ears, you take 2d4 bludgeoning damages and make a constitution saving throw. On a success you are immune to any effect that would sense your emotions or read your thoughts and the charmed condition for the next minute.
3. Gotta go fast. You can move up to 100 ft.
   • Echoed: You can move up to 30 ft.
4. Not on my watch. You are no longer surprised.
   • Echoed: If you would be surprised make a initiative check, you are no longer surprised if you get more than the best initiative in the group that surprised you.
5. My turn. When you would roll for initiative you can choose to get an initiative of 100 instead.
   • Echoed: After you rolled for initiative you can roll an additional d20, you choose which one of the d20 is used.
6. My Head is Bloody, but Unbowed. After failing a weapon attack roll you can choose to succeed instead.
   • Echoed: After failing a weapon attack roll you can roll an additional d20, you choose which one of the d20 is used.
7. Hit Good. For the next minute you can add 1d12 to all your weapon attack rolls.
   • Echoed: For the next minute you can add 1d4 to all your weapon attack rolls.
8. Hit Strong. For the next minute you can add 1d12 to all your weapon damage.
   • Echoed: For the next minute you can add 1d4 to all your weapon damage.
9. Protection. As a reaction you can move up to 30 ft and take the place of an other willing character. You push this other character 20 ft in any direction.
   • Echoed: As a reaction you can move up to 10 ft and take the place of an other willing character. You push this other character 10 ft in any direction.
10. Swimming whirlwind. You are so strong that you can create current in the water that can pull enemies toward you or unbalance them if they within 30 ft of you waist down in the same body of water. They must succeed an athletics check DC 10 + your Athletics bonus or be either pull towards you 20 ft and/or knocked prone, your choice.
    • Echoed: You are so strong that you can create current in the water that can pull enemies toward you or unbalance them if they within 10 ft of you waist down in the same body of water. They must succeed an athletics check DC 10 + your Athletics bonus or be either pull towards you 10 ft and/or knocked prone, your choice.
11. I have the high ground. You gain a climbing speed of 40 ft for the next 1 minute.
    • Echoed: You gain a climbing speed of 20 ft for the next 1 minute.

Non-tactical Heroic Actions (14)

1. Fear me. You intimidate target creature. They faint.
   • Echoed: When you make a successful Charisma (Intimidation) check one of the target faint.
2. Breathe. You can concentrate for 10 seconds, oxygenating your blood. You can then hold your breath for 10 additional minutes.
   • Echoed: You can concentrate for 1 minute, oxygenating your blood. You can then hold your breath for 1 additional minutes.
3. Who Needs a Ladder?” Add 8 ft to your next high jump.
   • Echoed: Make an athletics check DC 15, if you succeed add 8 ft to your next high jump.
4. See You on the Other Side. Add 29 ft to your next long jump.
   • Echoed: Make an athletics check DC 15, if you succeed add 29 ft to your next long jump.
5. Beast of Burden. For the next 10 minutes your carrying capacity is increased by 476 lb. (216 kg)
   • Echoed: For the next minute your carrying capacity is increased by 476 lb. (216 kg)
6. Know Your Enemy. You instantly know any two information of your choice about a target within 30 ft amongst: one ability score, level, CR, armor class, current hit point.
   • Echoed: After you spent one minute looking at a target you know any two information of your choice about a target within 30 ft amongst: one ability score, level, CR, armor class, current hit point.
7. I. Don’t. Fail. If you would fail at a Dexterity (Acrobatics) check you can choose to succeed instead.
   • Echoed: If you would fail at a Dexterity (Acrobatics) check you can roll an additional d20, you choose which one of the d20 is used.
   • This heroic action has several version: one per existing skill, you gain access to each of them separately.
8. Resist. If you would fail at a Strength saving throw you can choose to succeed instead.
   • Echoed: If you would fail at a Strength saving throw you can roll an additional d20, you choose which one of the d20 is used.
   • This heroic action has several version: one per saving ability, you gain access to each of them separately.
9. Skill Good. For the next minute you can add 1d12 to all your ability checks.
   • Echoed: For the next minute you can add 1d4 to all your ability checks.
10. War is its Own Language. By spending one minute interacting peacefully with a creature with at least one language you can then use sounds and gestures to talk to it as if you had proficiency in that creature language.
    • Echoed: By spending one minute interacting peacefully with a creature with at least one language you can then use sounds and gestures to talk to it as if you had proficiency in that creature language. It works as long as what you’re saying is not too complex (at the DM discretion).
11. Grift with Confidence. (inspired by Thirteen Expanded Feats/) If you succeed on a Charisma (Deception) check against a creature, the next Charisma (Deception) check you make receives a 1d8 bonus if it is made within 10 minutes of the previous check.
    • Echoed: If you succeed on a Charisma (Deception) check against a creature, the next Charisma (Deception) check you make receives a 1d4 bonus if it is made within 10 minutes of the previous check.
12. You can run… By focusing your senses you gain blindsight (15 ft) for 10 minutes.
    • Echoed: By focusing your senses you gain blindsight (15 ft) for 1 minutes.
13. Martial Command. (inspired by Player’s Handbook/Command spell) You speak a one-word command to a creature you can see within 60 ft. The target must follow the command on its next turn. This command has no effect if the target doesn’t understand your language, or if your command is directly harmful to it.
    • Echoed: You speak a one-word command to a creature you can see within 60 ft. The target must succeed on a Wisdom saving throw or follow the command on its next turn. This command has no effect if the target doesn’t understand your language, or if your command is directly harmful to it.
14. Choose Your Battles. You attempt to calm a group of people. Choose one of the following two effects. You can remove any effect causing a target to be frightened or charmed. Alternatively, you can make a target indifferent about any creatures of your choice. The effect of this feature last while you maintain a conversation with the targets with a maximum of one hour.
    • Echoed: You attempt to calm a group of people. Each creature that can hear and understand you must make a Charisma saving throw; a creature can choose to fail this saving throw if it wishes. If a creature fails its saving throw, choose one of the following two effects. You can remove any effect causing a target to be frightened or charmed. Alternatively, you can make a target indifferent about any creatures of your choice. The effect of this feature last while you maintain a conversation with the targets with a maximum of one minute.

Tier 2 (12)

Tactical Heroic Actions (6)

1. I will not yield. Instead of rolling a death saving throw you regain 1HP. You can then act normally.
   • Echoed: If you succeeded at a death saving throw you regain 1HP. You can then act normally.
2. Again. And again! On your turn, you can take two additional actions on top of your regular action and two possible bonus action.
   • Echoed, Again: On your turn, you can take one additional actions on top of your regular action and one possible bonus action.
3. Aware. For the next hour you can’t be surprised and have advantage on weapon attack rolls, ability checks, and saving throws. Additionally, other creatures have disadvantage on weapon attack rolls against you for the duration.
   • Echoed: For the next minute you can’t be surprised and have advantage on weapon attack rolls, ability checks, and saving throws. Additionally, other creatures have disadvantage on weapon attack rolls against you for the duration.
4. No. Counter a spell if the caster is within your weapon reach.
   • Echoed: Counter a spell if the caster is within your weapon reach and if the caster fails a constitution saving throw against your weapon DC.
5. In The Face. Your next attack is a critical hit.
   • Echoed: Your next attack is a critical hit on a 12 or above.
6. Look me in the Eyes. Each creature in a 30-foot cone drop whatever it is holding and become frightened for 3 rounds. While frightened by this effect, a creature must take the Dash action and try to move away from you on each of its turns.
   • Echoed: Each creature in a 30-foot cone must succeed on a Wisdom saving throw or drop whatever it is holding and become frightened for 3 rounds. While frightened by this effect, a creature must take the Dash action and try to move away from you on each of its turns. At the end of its turn if the creature doesn't have line of sight to you it can make a Wisdom saving throw which ends the effect on a success.

Non-tactical Heroic Actions (6)

1. Working Paragon. Something that would take up to 1 week to do with tools you are proficient with can be done 7 times as fast.
   • Echoed: Something that would take up to 1 day to do with tools you are proficient with can be done 3 times as fast.
2. I am the Master of my fate. After failing a ability check you can choose to succeed instead.
   • Echoed: After failing a ability check you can roll an additional d20, you choose which one of the d20 is used.
3. I am the Captain of my Soul. After failing a saving throw you can choose to succeed instead.
   • Echoed: After failing a saving throw you can roll an additional d20, you choose which one of the d20 is used.
4. Jump. You gain a flying speed equal to twice your walking speed for 2 round. After these 2 rounds you lose your vertical momentum and can't go up, you can still go straight or go down for one round. Then you fall.
   • Echoed: You gain a flying speed equal to your walking speed for 1 round.
5. Sword to Plowshare. In a impossible feat of strength and endurance you spend 8 hours working in the fields around you doing as much as dozen of other people. You enrich the land in a half-mile radius for 1 year. The plants yield twice the normal amount of food when harvested.
   • Echoed: In a impossible feat of strength and endurance you spend a week working in the fields around you doing as much as dozen of other people. You enrich the land in a half-mile radius for 1 year. The plants yield twice the normal amount of food when harvested.
6. Sage Advice (inspired by The Scholar/Sage Advice and Theoretical Advice) You may spread your knowledge and experience to those around you. You spend 1 minute advising your companions. When you do so, choose a skill or tool and a number of friendly creatures up to your Intelligence modifier who can understand, hear, and see you. Twice within the next hour, the next time each creature would make a check of the chosen skill or tool, they may add their proficiency modifier to the roll, or double their proficiency if they are already proficient.
   • Echoed: You may spread your knowledge and experience to those around you. You spend 1 minute advising your companions. When you do so, choose a skill or tool you are proficient with and a number of friendly creatures up to your Intelligence modifier who can understand, hear, and see you. Once within the next hour, the next time each creature would make a check of the chosen skill or tool, they may add their proficiency modifier to the roll, or double their proficiency if they are already proficient.

Tier 3 (6)

Non-tactical Heroic Actions (3)

1. Never Tell me the Odds. (inspired by Balsar’s Guide to Exploration/Foretell the Odds) Whenever a creature within range of your weapon makes an attack roll, ability check or saving throw, you may expend expand your reaction to have their roll become 2 or 18 (before any modifiers are applied). You can choose to do this after the roll, but before the dice outcome is deemed to be a success or failure.
   • Echoed: Whenever a creature within range of your weapon makes an attack roll, ability check or saving throw, you may expend expand your reaction to have their roll become 10 (before any modifiers are applied). You can choose to do this after the roll, but before the dice outcome is deemed to be a success or failure.
2. I’m on a Roll. You have advantage at all you ability checks for the next hours or until you fail one, whichever comes first.
   • Echoed: You have advantage at all you ability checks for the next minute or until you fail one, whichever comes first.
3. You Will Listen. If you were not behaving in an aggressive way any person within 30 ft that can see you is now paralyzed as long as you do not attack or for one minute, whichever comes first. You get advantage on any Charisma throw you could make during this time.
   • Echoed: If you were not behaving in an aggressive way any person within 30 ft that can see you is now stunned as long as you do not attack or for 10 seconds, whichever comes first.

Tactical Heroic Actions (3)

1. You’re going down. For the duration of this round all your attacks are critical hits.
   • Echoed: For the duration of this round all your attacks hit (you can still roll the dice in case of a critical hit).
2. 'Tis But a Scratch. You regain all your HP.
   • Echoed: You regain half your HP.
3. Won’t Go Down. As a reaction you can reduce to zero all the damage you would take during this round.
   • Echoed: As a reaction you can halve all the damage you would take during this round.

Optional Rules

Rogue Can do it Too

Normally Rogues don’t get access to heroic actions. With this optional rule they do.

Average Heroic Rank

If you decide to use this optional rule your heroic rank is determined by your level and your class instead of the standard way. Classes are divided in 4 categories:

• Full-casters (wizards, druids, bards, clerics, sorcerers) that have a 9th level spell slot as their higher level spell slot
• Half-casters (paladins, rangers, artificers, and for the purpose of this module, warlocks) that have a 5th level spell slot as their higher level spell slot
• Third-casters (fighters/eldritch knights, rogue/arcane trickster) that have a 4th level spell slot as their higher level spell slot
• Non-casters (fighters, barbarian, monk, rogue) that have no spell slots

You heroic rank is equal to (1/2 × the sum of your levels in half-caster classes rounded up) + (2/3 × the sum of you levels in third-caster classes rounded up) + the sum of your levels in non-caster classes.

Magic Spoils Everything

If you decide to use this optional rule your heroic rank is determined by your level and your class with the highest magic. If you only have levels in non-caster classes or third-caster classes you heroic rank is determined normally. If you have at least one level in a half-caster class then your heroic rank is halved. If you have at least one level in a full-caster class you have no heroic rank (and hence no heroic actions).

Closing Remarks

I’m not so sure about many things here. Why only 5 heroic action at the beginning and two more at each rank? I don’t know maybe it’s too much? Maybe not?

I like that the player is encouraged to use the action because otherwise the echoed is kind of “lost” but at the same time she is encouraged to keep it for when it really matters.

I’m not so sure about the division in tier. Maybe I should put everything in the same tier? Maybe tier 2 actions are better than tier 3?

Also maybe echoed actions should be stronger than heroic actions? That would give more incentive to use it.

There might be typos also, feel free to leave a comment about hat and I’ll fix them.

Anyway, I might update this article or add new actions in the future.

Je veux avoir quelque chose qui ressemble à des sorts, qui permet de choisir dans une longue liste d’option, qui est différent en terme de gameplay, et qui est extraordinaire ! Mais je ne veux pas que ça ressemble a une énième liste de sorts ni que ça utilise des emplacements de sorts. Et je veux en particulier améliorer l’expérience hors-combat (exploration et social), en combat je trouve que ça va.

Donc, j’ai commencé à travailler sur ce projet et il s’est un peu perdu dans les limbes … Récemment des gens ont parlé de la disparité des classe martiales sur Reddit et du fait que les combattants ont besoin d’avoir leur propre ressource similaire aux emplacements de sorts. J’avais déjà pensé aux concept des actions héroïques donc je me suis dit que j’allais essayé de terminer. Et voilà ce que j’ai pondu !

Je me suis demandé : “Qu’est-ce que les combattants sont sensé être ? Des héros. Et que font les héros ?”

• Ulysse trompe le Cyclop
• Indiana Jones échappe à un boulet qui aurait pu l’écraser et donne un coup de poing à Hitler
• Aragorn combat un troll et fait un discour inspirant à son armé devant les portes du Mordor
• Luke Skywalker fait un tire précis dans la bouche d’entrée ce qui fait explosé l’étoile de la mort
• Maximus impressione la foule et gagne son soutien

Ils font ça et bien d’autres choses. Mais ils font chacune des ces choses une fois. Et c’est ça l’idée. Une liste d’action héroïque qui ne peuvent être faite qu’une fois par personnage. Quand c’est fait, c’est fini !

Laissez moi donc vous présenter …

Le Chapitre des Héros

Les écrivains noircirons les pages avec vos histoires. Les philosophes analyserons vos actions. Les bardes chanteront vos aventures dans les tavernes tout autour du monde. L’histoire sera étudiée à travers le prisme de combat et de vos discours. Mais vous serez maudit car personne ne se souvient des 2ème fois.

Si vous êtes un guerrier, un barabare ou un moine vous avec accès aux actions héroïques. Vos range de héro est égale à la somme de vos niveaux dans ces classes et determine à combien d’actions héroïques vous avez accès. Si vous gagnez un niveau dans une autre classe classe vous perdez la possibilité de gagner de nouvelles actions héroïques.

La plupart des actions heroïques peuvent être utilisé à n’importe quel moment sans consommer d’action ou d’action bonus, il n’y a pas de limite au nombre d’action héroïques que vous pouvez utiliser pendant votre tour mais soyez économe car vous ne pouvez utiliser chaque action héroïque qu’une fois. Pas une fois par jour, pas une fois par repos long, pas une fois pas repos court, une fois.

Quand vous atteignez le rang de héros 1 vous choisissez vos 5 premières actions héroïques et vous apprenez en plus toutes les actions héroïque de tier 0. À chaque fois que vous gagnez un rang de héros vous apprennez 2 nouvelles actions héroïques.

Si votre rang de héros est de 4 ou moins vous avec uniquement accès au actions héroïques de tier 1. Quand vous atteigner le rang de héros 5 vous avez accès au actions de tier 2. Au rang de héros 11 vous avez accès au tier 3 des actions heroïques.

À chaque vous que vous utiliser une action héroïque vous ne pouvez plus l’utiliser à nouveau. Les gens chanterons vos exploits mais vous ne pourrez plus jamais refaire cet exploit. La prochaine fois que vous gagnez un niveau vous apprenez automatiquement le version echo de cette action héroïque qui ne peut, elle aussi, être utilisé qu’une fois.

Quelques une de vos actions héroïques necessite que la cible fasse un jet de sauvegarde. Le DD est calculé de la manière suivante : 8 + votre bonus de maîtrise + votre modificateur de force.

Actions Héroïques (44)

Tier 0 (1)

Actions Héroïques Générique (1)

1. Je sais. Vous pouvez apprendre n’importe quelle actions héroïque (que vous n’avez jamais apprise et jamais utilisé).
   • Echoed: Lors d'un repos court, vous pouvez passez un peu de temps à vous remémorez vos vielles aventures et apprendre n’importe quelle actions héroïque (que vous n’avez jamais apprise et jamais utilisé).

Tier 1 (25)

Actions Héroïques Tactique (11)

1. Je te vois. Vous pouvez lancer n'importe quelle arme comme s’il avait la propriété lancer avec une portée de 200 ft/600 ft.
   • Echoed: Vous pouvez lancer une arme avec la propriété lancer comme s’il avait la propriété lancer avec une portée de 200 ft/600 ft.
2. Je ne t’entends pas. Vous frappez vos oreilles, vous êtes immunisez à n’importe quelle effet qui devrait sentir vos émotions ou lire vos pensées ainsi qu’à la condition charmé pendant une minute.
   • Echoed: En tant qu'action vous frappez vos oreilles, vous subissez 2d4 dégât contondants et faites un jet de sauvegarde de constitution. Si c'est un succès vous êtes immunisez à n’importe quelle effet qui devrait sentir vos émotions ou lire vos pensées ainsi qu’à la condition charmé pendant une minute.
3. Plus vite. Vous pouvez vous déplacer de 100 pieds.
   • Echoed: Vous pouvez vous déplacer de 30 pieds.
4. Pas si je peux l’empêcher. Vous n’être plus surpris.
   • Echoed: Si vous deviez être surpris faite un jet d'initiative, vous n’être plus surpris Si vous avez plus d'initiative que la plus haute des initiative dans le groupe qui vous a surpris.
5. À mon tour. Quand vous devriez lancer l’inititive vous pouvez choisissez d'avoir une inititive de 100 à la place.
   • Echoed: Après avoir lancé l’inititive vous pouvez lancez un d20 en plus, vous choisissez quel résultat utiliser.
6. Ma tête est blessé mais haute. Après avoir échoué un jet d’attaque avec une arme vous pouvez choisir de réussir à la place.
   • Echoed: Après avoir échoué un jet d’attaque avec une arme vous pouvez lancer un d20 supplémentaire, vous choisissez quel résultat utiliser.
7. Frapper Bien. Pendant une minute vous pouvez ajouter 1d12 à tout vos jets d’attaque avec des armes.
   • Echoed: Pendant une minute vous pouvez ajouter 1d4 à tout vos jets d’attaque avec des armes.
8. Frapper Fort. Pendant une minute vous pouvez ajouter 1d12 à tous vos jets de dégâts.
   • Echoed: Pendant une minute vous pouvez ajouter 1d4 à tous vos jets de dégâts.
9. Protection. En tant que réaction vous pouvez vous déplacer de 30 pieds et prendre la place d’une autre personnage volontaire. Vous poussez ce personnage 20 pieds dans la direction de votre choix.
   • Echoed: En tant que réaction vous pouvez vous déplacer de 10 pieds et prendre la place d’une autre personnage volontaire. Vous poussez ce personnage 10 pieds dans la direction de votre choix.
10. Nage Tourbillonante. Vous êtes si fort que vous pouvez crééer un courant dans l’eau qui peut transporter ou destabiliser vos enemies s’ils sont à moins de 30 pieds de vous et au moins jusqu’à la taille dans la même étendue d’eau. Ils doivent réussir un jet de Force (Athelisme) DD 10 + votre bonus d’Athelisme or être soit tiré vers vous de 20 pieds et/ou être mis à terre, c’est vous qui choisissez.
    • Echoed: Vous êtes si fort que vous pouvez crééer un courant dans l’eau qui peut transporter ou destabiliser vos enemies s’ils sont à moins de 10 pieds de vous et au moins jusqu’à la taille dans la même étendue d’eau. Ils doivent réussir un jet de Force (Athelisme) DD 10 + votre bonus d’Athelisme or être soit tiré vers vous de 10 pieds et/ou être mis à terre, c’est vous qui choisissez.
11. Je te Domine. Vous gagner une vitesse d’escalade de 40 pieds pendant 1 minute.
    • Echoed: Vous gagner une vitesse d’escalade de 20 pieds pendant 1 minute.

Actions Héroïques Non-tactique (14)

1. Tu devrais avoir peur de moi. vous intimidez la cible. Elle s’évanouie.
   • Echoed: Quand vous réussisez un jet de Charisme (Intimidation) une des cible s’évanouie.
2. Respire. Vous pouvez vous concentrer pendant 10 secondes, oxygéant votre sang. Vous pouvez retenir votre respiration pour 10 minutes supplémentaires.
   • Echoed: Vous pouvez vous concentrer pendant 1 minute, oxygéant votre sang. Vous pouvez retenir votre respiration pour 1 minutes supplémentaires.
3. Les échelles sont inutiles Ajoutez 8 pieds à votre prochain saut en hauteur.
   • Echoed: Faites un jet de Force (Athlétisme) DD 15, si vous réussissez ajoutez 8 pieds à votre prochain saut en hauteur.
4. On se voit de l’autre côté. Ajoutez 29 ft à votre prochain saut en longeur.
   • Echoed: Faites un jet d'Athletisme DD 15, si vous réussissez ajoutez 29 ft à votre prochain saut en longeur.
5. Bête de bat. Pendant 10 minutes vous pouvez portez 476 lb. (216 kg) de plus.
   • Echoed: Pendant 1 minute vous pouvez portez 476 lb. (216 kg) de plus.
6. Connais ton ennemi. Instantanément, vous apprennez deux informations de votre choix à propos d’une cible qui est à moins de 30 pieds de vous parmi: un score de caractéristique, niveau, CR, classe d’armure, point de vie actuel.
   • Echoed: Après avoir passez une minute à observer une cible vous apprennez deux informations de votre choix à propos d’une cible qui est à moins de 30 pieds de vous parmi: un score de caractéristique, niveau, CR, classe d’armure, point de vie actuel.
7. Je. N’échoue. Pas. Si vous deviez échouer à un jet de Dextérité (Acrobatie) vous pouvez choisir de réussir à la place.
   • Echoed: Si vous deviez échouer à un jet de Dextérité (Acrobatie) vous pouvez lancer un d20 supplémentaire, vous choisissez quel résultat utiliser.
   • Cette action héroïque a plusieurs versions: une par compétence, vous apprennez chacune d’entre elles séparément.
8. Resiste. Si vous deviez échouer à un jet de sauvegarde de force vous pouvez choisir de réussir à la place.
   • Echoed: Si vous deviez échouer à un jet de sauvegarde de force vous pouvez lancer un d20 supplémentaire, vous choisissez quel résultat utiliser.
   • Cette action héroïque a plusieurs versions: une par jet de sauvegarde, vous apprennez chacune d’entre elles séparément.
9. Compétence Bien. Pendant une minute vous pouvez ajouter 1d12 à tout vos jet de compétence.
   • Echoed: Pendant une minute vous pouvez ajouter 1d4 à tout vos jet de compétence.
10. La Guerre est un Langage. En passant une minute à interagir pacifiquement avec une creature qui a au moins un langage vous pouvez ensuite utiliser des sons et des gestes pour communiquer avec cette créature comme si vous maitrisiez dans la langue de cette créature.
    • Echoed: En passant une minute à interagir pacifiquement avec une creature qui a au moins un langage vous pouvez ensuite utiliser des sons et des gestes pour communiquer avec cette créature comme si vous maitrisiez dans la langue de cette créature. Cela fonctionne tant que ce que vous dites n'est pas trop compliqué (à la discrétion du MJ).
11. Escroquer avec Confiance. (inspired by Thirteen Expanded Feats/) Si vous réussissez à un jet de Charisme (Tromperie) contre une créature, le prochaine jet de Charisme (Tromperie) que vous faites à un bonus de 1d8 s’il est fait dans les 10 minutes qui suivent le prmier jet.
    • Echoed: Si vous réussissez à un jet de Charisme (Tromperie) contre une créature, le prochaine jet de Charisme (Tromperie) que vous faites à un bonus de 1d4 s’il est fait dans les 10 minutes qui suivent le prmier jet.
12. Vous Pouvez Toujours Courrir … En vous concentrant sur vos sens vous gagnez une vision aveugle (15 pieds) pendant 10 minutes.
    • Echoed: En vous concentrant sur vos sens vous gagnez une vision aveugle (15 pieds) pendant 1 minutes.
13. Ordre Martial. (inspired by Player’s Handbook/Command spell) Vous donnez un ordre d’un mot à une créature à moins 60 pieds ou moins et que vous pouvez voir. La cible doit suivre l’ordre lors de son prochain tour. Cet ordre n’a aucun effet si la cible ne comprend pas votre langue, ou si votre ordre est directement nocif pour elle.
    • Echoed: Vous donnez un ordre d’un mot à une créature à moins 60 pieds ou moins et que vous pouvez voir. La cible doit succeed on a Wisdom saving throw or suivre l’ordre lors de son prochain tour. Cet ordre n’a aucun effet si la cible ne comprend pas votre langue, ou si votre ordre est directement nocif pour elle.
14. Choisis tes Combats. Vous essayez de calmer un groupe de personne. Choisissez l'un des deux effets suivants. Vous pouvez annuler tout effet faisant qu’une créature est effrayé ou charmée. Alternativement, vous pouvez faire qu’une cible devienne indiférente à une créature de votre choix. Les effets durent tant que vous continuer à converser avec les cibles pour une durée maximume de une heure.
    • Echoed: Vous essayez de calmer un groupe de personne. Chaque créature qui peut vous entendre et vous comprendre doit faire un jet de sauvegarde de Charisme; une créature peut choisir d'échouer à ce jet de sauvegarde si elle le souhaite. Si une créature échoue à son jet de sauvegarde choisissez l'un des deux effets suivants. Vous pouvez annuler tout effet faisant qu’une créature est effrayé ou charmée. Alternativement, vous pouvez faire qu’une cible devienne indiférente à une créature de votre choix. Les effets durent tant que vous continuer à converser avec les cibles pour une durée maximume de une minute.

Tier 2 (12)

Actions Héroïques Tactique (6)

1. Je ne m’inclinerai pas. Au lieu de faire un jet de sauvegarde contre la mort vous regagner 1 point de vie. Vous pouvez ensuite agir normalement.
   • Echoed: Si vous réussissez un jet de sauvegarde contre la mort vous regagner 1 point de vie. Vous pouvez ensuite agir normalement.
2. Encore. Et encore ! Pendant votre tour vous pouvez réaliser deux action supplémentaires en plus de vos actions habituelles et deux action bonus.
   • Echoed, Encore: Pendant votre tour vous pouvez réaliser une action supplémentaires en plus de vos actions habituelles et une action bonus.
3. Consient. Pendant la prochaine hour vous ne pouvez pas être surpris et avez l’avantage au jet d’attaque avec une armes, jets de compétence, et jets de sauvegarde. De plus, les autres créatures on un désavantage aux jet d’attaque avec une armes contre vous pendant cette même durée.
   • Echoed: Pendant la prochaine minute vous ne pouvez pas être surpris et avez l’avantage au jet d’attaque avec une armes, jets de compétence, et jets de sauvegarde. De plus, les autres créatures on un désavantage aux jet d’attaque avec une armes contre vous pendant cette même durée.
4. Non. Contrecarrer un sort si le lanceur est à portée de votre arme.
   • Echoed: Contrecarrer un sort si le lanceur est à portée de votre arme et si le lanceur échoue à un jet de sauvegarde contre votre DD d'arme.
5. Dans la Tête. Votre prochaine attaque est un coup critique.
   • Echoed: Votre prochaine attaque est un coup critique sur un 12 ou plus.
6. Regarde Moi dans les Yeux. Chaque créatire dans un cône de 30 pieds lâche tout ce qu’elle tient et devient effrayée pendant 3 tours. Tant qu’elle est effrayée par cet effet une créature doit utiliser l’action Foncer pour s’éloigner de vous à chacun de ses tours.
   • Echoed: Chaque créatire dans un cône de 30 pieds must succeed on a Wisdom saving throw or lâche tout ce qu’elle tient et devient effrayée pendant 3 tours. Tant qu’elle est effrayée par cet effet une créature doit utiliser l’action Foncer pour s’éloigner de vous à chacun de ses tours. À la fin de son tour, si la créature ne vous voit pas elle peut faire un jet de sauvegarde de Sagesse et mettre fin à l'effet en cas de succès.

Actions Héroïques Non-tactique (6)

1. Paragon d’Effort. Quelque chose qui devrait prendre jusqu’à une semaine pour être fait avec des outils que vous maîtrisez peut être fait 7 fois plus vite.
   • Echoed: Quelque chose qui devrait prendre jusqu’à un jour pour être fait avec des outils que vous maîtrisez peut être fait 3 fois plus vite.
2. Je Suis le Maître de mon Destin. Après avoir échoué un jet de compétence vous pouvez choisir de réussir à la place.
   • Echoed: Après avoir échoué un jet de compétence vous pouvez lancez un d20 en plus, vous choisissez quel résultat utiliser.
3. Je Suis le Capitaine de mon Âme. Après avoir échoué a un jet de sauvegarde vous pouvez choisir de réussir à la place.
   • Echoed: Après avoir échoué a un jet de sauvegarde vous pouvez lancez un d20 en plus, vous choisissez quel résultat utiliser.
4. Saute. Vous gagnez une vitesse de vol égale à deux fois votre vitesse de marche pendant 2 round. Après ces 2 rounds vous ne pouvez plus monter mais vous pouvez toujours aller tout droit ou vers le bas pour un round. ENsuite, vous tombez.
   • Echoed: Vous gagnez une vitesse de vol égale à votre vitesse de marche pendant 1 round.
5. Retour au Pays. Avec une démonstration de force et d’endurance impossible vous passez 8 heures à travailler dans les champs autour de vous, réalisant un travail équivalent à celui de dizaines de personnes. Vous enrichissez le sol pour une année dans une zone de 800 mètres de rayon. Les plantes produisent deux fois plus de nourriture lors de la récolte.
   • Echoed: Avec une démonstration de force et d’endurance impossible vous passez une semaine à travailler dans les champs autour de vous, réalisant un travail équivalent à celui de dizaines de personnes. Vous enrichissez le sol pour une année dans une zone de 800 mètres de rayon. Les plantes produisent deux fois plus de nourriture lors de la récolte.
6. Conseil de Sage (inspired by The Scholar/Sage Advice and Theoretical Advice) Vous pouvez transmettre vos connaissances et votre experience à ceux autour de vous. Vous passez une minute à conseiller vos compagnons. Quand vous faites ceci, choisissez une compétence ou un outils et un nombre de créature égale à votre modificateur d’Intelligence qui peuvent vous comprendre, vous voir et vous entendre. Deux fois pendant la prochaine heure, quand la créature devrait faire un jet de compétence ou d’outils que vous avez choisis elle peut ajouter son bonus de maitrise au jet, ou le double si elle le maitrisait déjà.
   • Echoed: Vous pouvez transmettre vos connaissances et votre experience à ceux autour de vous. Vous passez une minute à conseiller vos compagnons. Quand vous faites ceci, choisissez une compétence ou un outils you are proficient with et un nombre de créature égale à votre modificateur d’Intelligence qui peuvent vous comprendre, vous voir et vous entendre. Une fois pendant la prochaine heure, quand la créature devrait faire un jet de compétence ou d’outils que vous avez choisis elle peut ajouter son bonus de maitrise au jet, ou le double si elle le maitrisait déjà.

Tier 3 (6)

Actions Héroïques Non-tactique (3)

1. Ne me Dit Jamais la Cote ! (inspired by Balsar’s Guide to Exploration/Foretell the Odds) Quand une créature à portée de votre arme fait un jet d’attaque, un jet de compétence ou un jet de sauvegarde, vous pouvez utilisez votre réaction pour faire que leur lancer devienne 2 ou 18 (avant les modificateurs). Vous pouvez choisir de faire ceci après le lancer, mais avant que le succès ou l’echec soit annoncé.
   • Echoed: Quand une créature à portée de votre arme fait un jet d’attaque, un jet de compétence ou un jet de sauvegarde, vous pouvez utilisez votre réaction pour faire que leur lancer devienne 10 (avant les modificateurs). Vous pouvez choisir de faire ceci après le lancer, mais avant que le succès ou l’echec soit annoncé.
2. Je suis en Veine. Vous avez l’avantage à tous vos jet de caracteristique pendant You have advantage at all you ability checks for the une heure ou jusqu’à ce que vous échouillez à l’un d’entre eux, le premier des deux prévalant.
   • Echoed: Vous avez l’avantage à tous vos jet de caracteristique pendant You have advantage at all you ability checks for the une minute ou jusqu’à ce que vous échouillez à l’un d’entre eux, le premier des deux prévalant.
3. Tu Vas m’Écouter. Si vous ne vous comportez pas de manière agressive avec aucune des personne qui peut vous voir dans un rayon de 30 pieds paraliser tant que vous n’attaquez pas ou pour une minute, le premier des deux prévalant. Vous avez l'avantage aux jets de Charisme que vous faites pendant cette periode.
   • Echoed: Si vous ne vous comportez pas de manière agressive avec aucune des personne qui peut vous voir dans un rayon de 30 pieds étourdi tant que vous n’attaquez pas ou pour 10 secondes, le premier des deux prévalant.

Actions Héroïques Tactique (3)

1. Toi tu Crèves. Pendant ce tour toutes vos attaques sont des coups critiques.
   • Echoed: Pendant ce tour toutes vos attaques touchent (vous pouvez still roll the dice in case of a critical hit).
2. Ce n’est qu’une Égratignure. Vous regagnez tout vos points de vie.
   • Echoed: Vous regagnez la moitié de vos points de vie.
3. Toujours Debout. Vous pouvez utiliser votre reaction pour récuire à zéro tous les dégâts que vous allez prendre pendant ce tour.
   • Echoed: Vous pouvez utiliser votre reaction pour diviser par deux tous les dégâts que vous allez prendre pendant ce tour.

Règles Optionnelles

Les Roublard Sont Autorisés

Normallement les roublards ne peuvent pas utiliser les actions heroïques, avec cette règle il peuvent.

Niveau de Héros Moyen

Si vous décidez d’utiliser cette règle optionnelle votre rang de héros est determiné par vos niveaux dans chacune de vos classes. Les classes sont réparties en 4 catégories :

• Lanceurs de sorts complets (magicien, druides, bardes, clercs, sorciers) qui ont un emplacement de sorts de niveau 9 comme emplacement de sort de plus haut niveau
• Demi lanceurs de sorts (paladins, rôdeurs, artificers, et pour ce qui est de ce module les occultistes) qui ont un emplacement de sorts de niveau 5 comme emplacement de sort de plus haut niveau
• Tiers lanceurs de sorts (guerrier/chevalier occultes, roublards/escroc arcanique) qui ont un emplacement de sorts de niveau 4 comme emplacement de sort de plus haut niveau
• Non lanceurs de sorts (guerrier, barbare, moine, roublard) qui n’ont pas de sorts

Votre rang de héro est égale à (1/2 × la somme de vos niveau dans des classes étant de demi lanceur de sorts) + (2/3 × la somme de vos niveau dans des classes étant de tiers lanceur de sorts) + la somme de vos niveau dans des classes non lanceur de sorts.

La Magie Gâche Tout

Si vous décidez d’utiliser cette règle optionelle votre rang héroïque est déterminé par votre classe ayant le niveau de magie le plus élevé. Si vous avez uniquement des niveaux dans des classe qui ne lancent pas de sorts ou tiers lanceur de sorts alors votre rang de héro est calculé normalement. Si vous avez au moins un niveau dans une classe demi lancer de sorts alors votre rang de héro est divisé par deux. Si vous avez un niveau dans une classe qui est lanceur de sorts complet alors vous n’avez pas de rang de héro (et donc pas d’actions héroïques).

Conclusion

Il y a beaucoup de choses dont je ne suis pas sûr. Pourquoi seulement 5 actions héroïques au début et deux de plus à chaque rang ? Peut-être que c’est trop ? Peut-être pas ?

J’aime que la joueuse soit encouragée à utiliser les actions parce que sinon la version écho et en quelques sortes perdue mais en même temps elle est aussi encouragée à la garder pour un moment très important.

Je ne suis pas certain de la division en tiers. Peut-être que je devrais tout mettre dans le même tier ? Peut-être que les actions de tier 2 sont meilleurs que celles du tier 3 ?

Aussi, peut-être que les écho devraient être plus fort que les version normales ? Ça inciterait plus à les utiliser.

Il y a probablement des fautes dans l’article, laissez un commentaire et je corrigerai.

Peut-être qu’un jour je mettrai à jour cette article avec de nouvelles actions.

The idea behind those function is that for an object o with a method f we have o.f(a) equivalent to o.f.apply(o, [a]) or o.f.bind(o)(a).

The problem is that their respective typings made for Typescript are too permissive for my own taste. They allow too much.

class Plane {
    flyTo(lat: number, lon: number): string {
        return "flying to " + lat + ", " + lon;
    }
}

let o: Object = new Object();
let p: Plane = new Plane();

p.flyTo.apply(p, [1, 2]);
p.flyTo.apply(o, [1, 2]); // I don't want that to typecheck! o is not a plane.

For reference here are the typings for those functions in the typescript library (you can skip them if you want):

interface Function {
    apply(this: Function, thisArg: any, argArray?: any): any;

    call(this: Function, thisArg: any, ...argArray: any[]): any;

    bind(this: Function, thisArg: any, ...argArray: any[]): any;

    // ...
}

interface CallableFunction extends Function {
    apply<T, R>(this: (this: T) => R, thisArg: T): R;
    apply<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, args: A): R;

    call<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, ...args: A): R;

    bind<T>(this: T, thisArg: ThisParameterType<T>): OmitThisParameter<T>;
    bind<T, A0, A extends any[], R>(this: (this: T, arg0: A0, ...args: A) => R, thisArg: T, arg0: A0): (...args: A) => R;
    bind<T, A0, A1, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1): (...args: A) => R;
    bind<T, A0, A1, A2, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2): (...args: A) => R;
    bind<T, A0, A1, A2, A3, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3): (...args: A) => R;
    bind<T, AX, R>(this: (this: T, ...args: AX[]) => R, thisArg: T, ...args: AX[]): (...args: AX[]) => R;
}

interface NewableFunction extends Function {
    apply<T>(this: new () => T, thisArg: T): void;
    apply<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, args: A): void;

    call<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, ...args: A): void;

    bind<T>(this: T, thisArg: any): T;
    bind<A0, A extends any[], R>(this: new (arg0: A0, ...args: A) => R, thisArg: any, arg0: A0): new (...args: A) => R;
    bind<A0, A1, A extends any[], R>(this: new (arg0: A0, arg1: A1, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1): new (...args: A) => R;
    bind<A0, A1, A2, A extends any[], R>(this: new (arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1, arg2: A2): new (...args: A) => R;
    bind<A0, A1, A2, A3, A extends any[], R>(this: new (arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1, arg2: A2, arg3: A3): new (...args: A) => R;
    bind<AX, R>(this: new (...args: AX[]) => R, thisArg: any, ...args: AX[]): new (...args: AX[]) => R;
}

I wanted to add my own definitions to the typescript standard library but I’m not a fan of editing a code that could be erased with an update so I made wrappers. The first iteration was:

function safeApply<T extends (...args: any) => any>(fun: T, thisArg: ThisParameterType<T>, args: Parameters<T>): ReturnType<T> {
    return fun.apply(thisArg, args);
}

function safeBind<T extends (...args: any) => any>(fun: T, thisArg: ThisParameterType<T>): (...args: Parameters<T>) => ReturnType<T>{
    return fun.bind(thisArg);
}

For those who don’t know ThisParameterType, Parameters and ReturnType all comes from the utility types provided by typescript:

/**
 * Obtain the parameters of a function type in a tuple
 */
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

/**
 * Extracts the type of the 'this' parameter of a function type, or 'unknown' if the function type has no 'this' parameter.
 */
type ThisParameterType<T> = T extends (this: infer U, ...args: any[]) => any ? U : unknown;

The syntax is weird, it uses conditional-types which are conditions evaluated at type checking time. The doc says:

A conditional type selects one of two possible types based on a condition expressed as a type relationship test:

T extends U ? X : Y

The type above means when T is assignable to U the type is X, otherwise the type is Y.

So type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never; would read something like The type Parameter<T>, which is only valid if T is a function ((...args: any) => any is a function), is either:

• P if T is a function with the list of arguments is of type P
• never otherwise

// Basically this means that all of this is correct
let par: Parameters<Plane["flyTo"]> = [1, 2]; // because the arguments of the flyTo method are [number, number]
let ret: ReturnType<Plane["flyTo"]> = "some string"; // because flyTo returns a string
let thi: ThisParameterType<Plane["flyTo"]> = undefined; // because ... well, I don't really know, it should be Plane, we are going to fix that

Why does ThisParameterType<Plane["flyTo"]> evaluates to undefined? Apparently it’s because typescript need to be said what is the type of this in the function. Like that:

class Plane {
    flyTo(lat: number, lon: number): string {
        return "flying to " + lat + ", " + lon;
    }

    flyToWithThis(this: Plane, lat: number, lon: number): string {
        return "flying to " + lat + ", " + lon;
    }
}

function() {
    let o: Object = new Object();
    let p: Plane = new Plane();

    safeApply(p.flyToWithThis, p, [1, 2]); // this works, so far so good
    safeApply(p.flyToWithThis, o, [1, 2]); // and this gives an error! Finally!
    /*
    Argument of type 'Object' is not assignable to parameter of type 'Plane'.
        The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
            Type 'Object' is missing the following properties from type 'Plane': flyTo, flyToWithThists(2345)
    */

    let thi: ThisParameterType<Plane["flyToWithThis"]> = new Plane(); // no surprise here

Ok, so I have to put the this: type thingy in every function that I plan to call apply (or bind) on. Ok, I’ll do it. But what if I forgot? What if, at one point, I call bind and forgot to put the this: type thingy in here, it would be nice if typescript would give me a warning. Because safeApply(p.flyTo, o, [1, 2]); still typecheck.

The problem is that ThisParameterType returns unknown when there is no this: type thingy, and an unknown parameter can be assigned anything (which is completly normal), so let’s change that:

type     ThisParameterType<T> = T extends (this: infer U, ...args: any[]) => any ? U                                                             : unknown;
type SafeThisParameterType<T> = T extends (this: unknown, ...args: any[]) => any ? never : (T extends (this: infer U, ...args: any[]) => any ? U : never );

So SafeThisParameterType<T> is never unless T has a this: type thingy, in which case it is the type of the list of arguments taken by T (T is still a function).

And safeApply and safeBind become:

function safeApply<T extends (...args: any) => any>(fun: T, thisArg: SafeThisParameterType<T>, args: Parameters<T>): ReturnType<T> {
    return fun.apply(thisArg, args);
}

function safeBind<T extends (...args: any) => any>(fun: T, thisArg: SafeThisParameterType<T>): (...args: Parameters<T>) => ReturnType<T>{
    return fun.bind(thisArg);
}

function() {
    let o: Object = new Object();
    let p: Plane = new Plane();

    safeApply(p.flyToWithThis, p, [1, 2]); // still works, good
    safeApply(p.flyToWithThis, o, [1, 2]); // still an error, still good
    /*
    Argument of type 'Object' is not assignable to parameter of type 'Plane'.
        The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?
            Type 'Object' is missing the following properties from type 'Plane': flyTo, flyToWithThists(2345)
    */

    safeApply(p.flyTo, p, [1, 2]); // gives an error! Yay! I won't forgot to add this: type
    // Argument of type 'Plane' is not assignable to parameter of type 'never'.ts(2345)

All is good.

Obviously there is weird cases where it would make sense to use bind/call in a situation where safeBind/safeCall gives an error, in which case you are free to use them if you know what you’re doing. I often don’t.

My party was in a fight; I was low and I wanted to try to intimidate the enemy to buy some time. My DM flat out told me, “You need to roll a 25 or higher.” My Intimidation bonus was +6, so I had to roll a 19 or 20. I succeeded! Great right? Guess what happened next. The enemy magic missiled me out of ‘fear’. I went down. One thing lead to another and we TPK’d. Fuck. My DM later told me that if I failed the enemy would’ve ignored me and attacked another party member who had more HP.

The results to this action mostly revolve around:

1. The enemy is intimidated and either
   1. decides to attack the character because they are now the main menace
   2. or decides to attack someone else because …fear!
2. The enemy is not intimidated and decides to continue as if nothing happened

2 is clearly a failure. 1.1 is a success if you wanted to (a) draw the aggro, a failure if (b) you wanted anything else (like making the enemy lose a turn or retreat). 1.2 is a success if you wanted to (a) avoid getting hit, (b) a failure otherwise.

Intent matters. The player succeeded at their roll and didn’t want to draw aggro and the DM decided that since 1.1.a could be considered a success in certain situations, it could be the result of any successful roll.

That is true, it could. Gotcha moments can be fun. Adversarial relationship with the DM can be fun.

But in my opinion, surprising the players with a different kind of adjucation can cause problems. Since the players are not able to reasonably predict the results of their action they might be tempted to do only simple actions. And then we will have players only doing thing like attacking in combat, never jumping over a fence, never trying to use a spell in an original way, because they’ll know that the risks outweigh the potential reward.

Personally, I try to be open about the potential results of an action, a simple “you don’t really know what’s gonna happen if you do that” often suffice.

Of course those is just my opinion, so do what you want.

How it works RAW

• Dropping something you are holding is a free action
• You have one interaction per turn such as drawing a weapon

Which means that if you’re holding nothing in your hand you can use your interact action to draw a weapon. If you need to draw an other weapon in your other hand (or interact with an other object) you need to use you action to do so, that’s one of the perks of the Dual Wielder feat.

What about switching weapons (meaning that you are already holding one)? Let’s say you are using a short sword and that you want to draw your bow. You may do it one of two ways:

1. Sheathe your shortsword weapon with your “interaction”
2. Draw your bow with your action, you have to use your action because you already used your one interaction Or:
3. Drop your sword of the ground (free action)
4. Draw your bow with your one interaction
5. Fire!

An interaction is defined at the page 190 of the PHB:

You can also interact with one object or feature of the environment for free, during either your m ove or your action. For example, you could open a door during your move as you stride toward a foe, or you could draw your weapon as part of the same action you use to attack.

If you really don’t want do drop your weapon the first one is better but it’s infrequent enough so that it doesn’t really matter, so in general the second way is better. But I think it’s stupid so let’s make a rule to make it better!

Change, change change change

What we don’t want:

• Characters switching weapons between attacks without penalty
• Characters switching weapons multiple times per turn without penalty

So let’s say:

You can switch weapon whenever you want but the next attack is made with a disadvantage

There is good things about this rule:

• Character with multiple attacks are less disadvantaged than others wince a lower ratio of their attacks will be made with disadvantaged. Martial character should be better in combat so it doesn’t bother me.

There is a few problems with this rule:

• It allows a caster to switch weapon and, after that, cast a spell that is not an attack without penalty
• When you are already at disadvantage switching to your melee weapon is free (when you’re holding a ranged weapon in melee for example).

So let’s change the rule to:

If you would make an attack during your turn without having a disadvantage you can choose to make this attack with a disadvantage and interact with one object or feature of the environment for free as part of this attack.

Next time we’ll talk about how to cast spells while you hand aren’t free, it’s more complicated than one can think…

1. Not caring
2. Using the normal rule, a character can carry its strength score time 15 in pound
3. Use the variant encumbrance rule
   • A character can carry up to 5 times its strength score with no problem
   • Between 5 and 10 times its strength score (it is encumbered) with a 10ft penalty to movement
   • Between 10 and 15 times its strength score (it is heavily encumbered) with a 20ft penalty to movement and you have disadvantage on ability checks, attack rolls, and saving throws that use Strength, Dexterity, or Constitution.

The thing is, unless you are using something that always compute the total weight of the stuff you are carrying it’s a hassle. What I don’t want in a weight system:

1. Carrying 100s of arrows, or darts
2. Carrying 4 different heavy armors
3. Carrying a carriage and 3 barrels on your back
4. Carrying a dozens of weapons like great club, pike, heavy crossbow, great axe, swords …
5. Having to look for the weight of every object in a table

We define the notion of Lower Bound Carrying Capacity (LBCC) so that when you are over your LBCC you are also over your carrying capacity. Basically we are going to have two kind of items:

• Bulky items that we count towards encumbrance
• Small items that don’t count towards encumbrance but are limited in number

Let’s start with the normal rule (“a character can carry its strength score time 15 in pound”). If our strength score is S we can carry no more than S items of 15 pound. or 2×S items of 7.5 pounds, or 3×S items of 5 pound, … you get the idea.

First let’s look at the minimum, maximum and median weight of items by category:

You can see that some of those things weight 600lb, we are going to remove everything 70lb or above from the dataset because they are obviously bulky and you don’t really need a rule for them.

Let’s see all that in a bubble graph with a log scale (btw, I couldn’t directly add a text label to the horizontal axes on google sheet, anybody knows if it’s possible?):

A few things that you can deduce from this chart to help you read it:

• All gaming sets weight 5lb or less
• All mounts and vehicles weight weight 8lb or more

Very Easy Weight System aka VEWS

We can see that a lot of categories are either over or under 5lb, so that may be a good tipping point to declare something bulky ou our LBCC weight system:

• Small, less than 5lb:
  • Simple melee weapons (except 1 in 10 at)
  • Simple ranged weapons
  • Martial ranged weapons (except 1 in 4 at 18lb)
  • Gaming sets
• Bulky, 5lb or more:
  • Tools
  • Armors
    • Shield
    • Light armor
    • Medium armor
    • Heavy armor
  • Mounts and vehicles
  • What is obviously heavy (Barrel, Chariot, Cart, Sled, Wagon, Carriage)
• Undecided (will be categorized as small, read the next paragraph):
  • Martial melee weapons
  • Musical instruments
  • Adventuring gear
  • Currency (I would use a separate rule for that anyway)

We have 4 undecided categories:

• I would use a separate weight system for currency (coins) anyway so it’s not a problem that this is undecided
• Lets’s put Martial melee weapons with other weapons in the small category, they are a little heavier but it’s more simple that way
• Adventuring gear is very diverse and most of it is light sot let’s put it in the small category
• Nobody cares how many musical instruments a character is carrying so let’s put it in the small category, and if a character want to have fun carrying multiple instruments I have no problem allowing it anyway

There is one thing that I don’t like at this point: weapons are small and that’s typically the kind of thing that my players will carry a lot of. That is why we are going to introduce one exception to the rule: groups of any 4 weapons are bulky.

So this system, that we’ll call Very Easy Weight System (VEWS), has 4 simple rules:

• Everything is small (which means it does count in the LBCC weight of the character) except that:
• Tools, armors, mounts and vehicles and items that are obviously heavy are bulky
• Groups of any 4 weapons are bulky
• Any group of 20 identical items is bulky (rations, arrows, bolts, …)

The normal rule (a character can carry its strength score time 15 in pound) becomes a character can carry a number of bulky things equals to 3 times its strength score, so a wizard with 10 strength could carry 30 bulks:

• 30 armors (30 bulks)
• or 10 armors (10 bulks) and 80 weapons (20 groups of 4 weapons for 20 bulky groups)

… which is ridiculous. And useless! So we’re going to have to rethink it.

Moderately Easy Weight System aka MEWS

Let’s start with the easiest thing, armors:

• Heavy armors weight at least 40lb so they now weight 8 bulk
• Medium armor weight at least 12lb so they weight 4 bulk, it should be 2 bulk but medium armor can weight up to 45lb (half-plate) so it’s probably better to go with 4 to avoid under estimate their weight
• Light armors weight at least 10lb so they now weight 2 bulks

Which gives us a nice geometrical 2, 4, 8 progression.

Also to avoid carrying character carrying an absurd number of of weapon let’s say that groups of any 2 (previously it was 4) weapons makes a bulk.

And finally, let change the rule for adventuring gear. There is not adventuring gear weighting between 6lb (pole, manacles, fine clothes, note that a shovel weight 5lb) and 10lb (chain, sledge hammer, hempen rope) which gives us a nice mental divide to divide the gear between bulky adventuring gear and light adventuring gear. At a glance we should be able to judge if an adventuring gear is lighter than a sledge hammer of close in weight to a shovel or heavier than a sledge hammer.

The updated rules for our Moderately Easy Weight System (MEWS) are:

1. Everything is small (which means it does count in the LBCC weight of the character) except that:
2. Tools, mounts and vehicles and items that are obviously heavy are bulky
3. Light armors are bulky, medium armors are twice that (= 4 bulks) and heavy armors are twice that (= 8 bulks)
4. Groups of any 2 weapons are bulky
5. Any group of 10 identical items is bulky (rations, arrows, bolts, … and yeah 9 arrows weight nothing)
6. Adventuring gear weight nothing if it like a pole or lighter, or be bulky if it’s heavier

With 30 bulks our 10 strength wizard can now carry:

• 15 light armors, and many light items
• or 3 heavy armors (24 bulks) and 12 weapons (6 groups of 2)
• or a more realist example, for a total of 23 bulks:
  • 1 heavy armor (8 bulk) looted on a bad guy that she’s bringing back to her friend the paladin
  • 1 medium armors (4 bulk) that is magical, she’s bringing it back to town to sell it
  • 4 weapons (2 bulks), two daggers, one quarter staff, one magical thingy
  • 2 tools (2 bulks), tinkerer and alchemist
  • 18 rations (1 bulks)
  • 25 arrows (2 bulks)
  • Bedroll and tent (2 bulks)
  • Rope (1 bulk)
  • Climber’s Kit (1 bulk)

Which is much more reasonable. The last example is ok for a wizards that is coming back from exploring a dungeon with some loot.

With the MEWS variant encumbrance rule:

• A character can carry up to its strength score in bulk with no problem
• Between once and twice its strength score in bulk an be encumbered: 10ft penalty to movement
• Between twice and 3 times its strength score in bulk and be heavily encumbered: 20ft penalty to movement and disadvantage on ability checks, attack rolls, and saving throws that use Strength, Dexterity, or Constitution.

These rules are more complicated than I would like but they have the advantage of using simple numbers and being possible to learn. Which mean that, with time, the GM and the players should be able to use them without thinking about it too much.

What I would like to do now is building an inventory sheet that makes counting weight easier, maybe a sheet with the 6 rules on top and a table with blocks of 4 bulks with dashed lines every two bulk and dotted lines for the remaining lines.

Inventory sheet in odt format.

I didn’t test this system so all of this is entirely speculative.

As usual, the data I computed in this post are available in ods format.