Introduction to Macro Branching/ja

From RPTools Wiki
Revision as of 06:57, 11 January 2020 by Fourwoods (talk | contribs)
Jump to navigation Jump to search

Languages:  English  • 日本語

INTERMEDIATE
THIS IS AN INTERMEDIATE ARTICLE

はじめに

When you write a macro, you'll frequently find yourelf wanting to either repeat an operation several times, or to choose from several options based on the outcome of a macro command. In game terms, you might want to make an damage roll several times in a row (say, one time for each enemy caught by a grenade blast), or you might want your macro to give you a damage roll if you hit, and say You missed! if you miss.

マクロを書いていると、何度も同じ処理を繰り返したり、マクロ・コマンドの結果に応じて複数の選択肢から一つを選んで実行したりしたくなることが良くある。ゲームを例に取るなら、（例えば手榴弾の爆発に複数の敵を巻き込んだときのように、）何度も続けてダメージ・ダイスを振りたいこともあるだろうし、また、もし攻撃が命中したらダメージ・ダイスを振り、外したらハズレ! と表示してくれるようなマクロを作りたいと考えるかも知れない。

In programming jargon, those concepts are called looping (where you go through a process repeatedly, or "loop through it"), and branching (where your program - in this case, the macro - "branches" down different paths). The MapTool macro language has several roll options (and one function) to let you branch and/or loop your commands.

プログラム用語では、こういう概念を繰り返し（一つの処理を繰り返す）と分岐（プログラム―ここではマクロだが―が異なる複数の処理に枝分かれする）と呼ぶ。MapToolのマクロ言語にはダイスを振るための複数のオプション（や関数）があり、これであなたの命令を分岐・繰り返しさせることができる。

Finally, because there are a lot of times when you'll want to do several things at the same time when you branch or loop, there's a special roll option called code that tells MapTool to treat several macro commands as a single "unit" when you loop or branch. That may sound confusing, but you'll see what it all means shortly!

そして最後に、分岐や繰り返しを使って一度に複数の事をさばきたいと感じるのは良くあることなので、繰り返しや分岐の際に複数のマクロ・コマンドをまとめて一つの「単位」として扱えるcodeというオプションも用意されている。ちょっと分かりにくいかも知れないが、すぐに分かるようになる。

Since there's a lot of ground to cover, this tutorial will cover branching (running different commands based on some condition). The Introduction to Macro Loops will handle looping (running a process repeatedly, until you wish it to stop).

話さなければならないことが沢山あるので、このチュートリアルでは分岐（ある条件によって異なる命令を実行する）について説明することにする。繰り返し（ある処理を止めるまで繰り返す）についてはIntroduction to Macro Loopsで解説する。

想定する読者

We're going to get to using these options pretty fast, so I assume you've read the Introduction to Macro Writing and have knowledge of how to create a new macro and use some very basic commands in it (like creating a variable or a dice roll).

これから急ぎ足でいろいろなオプションを使っていくことになる。そんなわけで、Introduction to Macro Writingを読み終え、新しいマクロの作り方を知っていて、その中に含まれていた（変数を作ったり、ダイス振りをしたりするなどの）基本的なコマンドが使えると想定することにする。

There are a couple concepts that should be introduced first, since they're going to be a great way to illustrate some of the branching concepts (and looping concepts, in the Introduction to Macro Loops. You'll get an explanation of the new concepts below.

まず最初にいくつかの概念を理解してもらうが、これは分岐という概念を（そしてこの先Introduction to Macro Loopsで説明する繰り返しの概念を）理解するという大変な作業を行うために必要だからだ。その新しい概念について、これから説明していこう。

新しい概念: CODE オプション

Normally, in any branching or looping technique, MapTool lets you do one thing - that is, one command. So if you had a statement that said "if a condition is true, do something cool," then "something cool" can only be one single thing - you might roll some dice, or assign a variable, or print out some text to the chat window. However, you couldn't roll some dice, assign a variable, assign another variable, do some math, and then print out something all in that statement. That's too many operations.

MapToolでは、分岐や繰り返しの技法を使うと、一つのことしかできないのが普通だ。この一つのこととは、つまりコマンド１個ということだ。だから「もしある条件が満たされたなら、なにかイケてることをしろ」では、この「なにかイケてること」の部分には一つのことしか入れられない。ダイスを振るとか、変数を宣言するとか、チャット・ウィンドウになにかのテキストを表示するとか、だ。しかし、ダイスを振って、変数を宣言して、さらにもう一つ変数を宣言して、計算を行い、それからそのなにかを出力する、といった処理はできない。処理の数が多すぎるからだ。

If you could only do one thing when you branch or loop, macros would be very limited - so the macro language supports a special roll option called [code():], which indicates to MapTool that you want to do several things at once, but have them all happen as a single "branch" or "loop." You would group these several commands inside a pair of curly braces ( { } ).

分岐や繰り返しを使うと一つのことしかできないというのでは、マクロの可能性は限られたものになってしまう。そこで、マクロ言語は特殊なロールのオプションを用意している。これが[code():]だ。これは、複数の処理を行いたいが、それが「分岐」や「繰り返し」の一つとして行われるべきだということをMapToolに伝えるためのものだ。複数のコマンドを一組の中カッコ（{}）の中に書く。

The examples below will use the [code():] option, so you can see how it works.

以下の例では[code():]のオプションを使っている。その仕組みが分かってもらえるだろう。

新しい概念: 比較演算子と論理演算子

In macro writing, you're going to want to compare values together a lot - is my dice roll greater than 20? Are my hit points less than 0? Does that weapon name equal "Warhammer?" All of these are handled via comparison operators and logical operators.

マクロを作成する場合、二つの数値を比べたいと考えることがよくある。ダイスの出目は20より大きいか？ ヒットポイントは 0　より小さいか？ その武器の名前は "Warhammer" と等しいか？

Comparison Operator is programming jargon for the symbols we use to have MapTool compare two values to each other in certain ways (an operator is a symbol that performs an operation - for instance, the + symbol is an operator that adds things together).

比較演算子とはプログラミングで用いる用語で、MapToolで二つの値を特定の基準で比べあうときに使う記号のことだ（演算子とは、ある演算を行うための記号だ）。例えば＋記号は加算を表す。

A Logical Operator is a symbol you use to instruct MapTool in what order to consider comparisons, and how to group comparisons together. The comparison and logical operators are described below:

論理演算子は、MapToolに対してどういう順番で比較を解釈したらよいか、それをどうまとめるかを教えるための記号だ。比較演算子と論理演算子については以下で説明する：

In the examples below, the if() function is used to illustrate the examples. It's described in more detail later, but the basic "format" of the if() function is this:

以下の例では、if() を使って説明している。これについては後でもう少し詳しく解説するが、基本的なif()の「文法」は以下の通りだ：

if(comparison, value_if_true, value_if_false)

if(比較, 真のときの値, 偽のときの値)

  • Comparison is where you do your actual comparison (greater than, less than, etc.)
  • Value_if_true is where you put the output or value if the comparison is true
  • Value_if_false is, obviously, where you put the output or value if the comparison is false
  • 比較は、実際に比較を行う部分（～より大きい、～より小さい、など）
  • 真のときの値は、比較結果が正しいときに出す出力や取る値を書く部分
  • 偽のときの値は、当然、比較結果が正しくないときに出す出力や取る値を書く部分　

比較演算子

The symbols below are the comparison operators. Remember that you must always think of these comparisons from the reference point of the value on the left side. So, in the comparison value1 > value2, you read it based on the left side: "is value1 greater than value2. This is the rule for comparisons in MapTool - the left side of the operator is the "point of view."

比較演算子を以下に挙げる。こうした比較は常に左辺値を起点として考えねばならない点に注意すること。だから、value1 > value2という比較では、左辺値を基本として「value1はvalue2よりも大きい」と読むことになる。これはMapToolで比較を行う場合の規則だ。演算子の左辺値がかならず比較の「視点」となる。

  • ==: "is equal to;" this is the operator you use to see if one value is equal to another. Be careful - it has two equals signs in a row (remember, one equal sign is already reserved for assigning values to variable). An example of this comparison would look like [if(hit == "yes", "you hit!", "you missed!")]
  • >: "is greater than; use this to see if the value on the left side is greater than the value on the right. For example: [if(roll > 17, "Hit!", "Miss")]. You can put a number on the left side, like [if(17 > roll, "Miss", "Hit!")] (note that it basically reverses the first example, so you need to switch the true and false outputs).
  • >=: "is greater than or equal to"; use this to see if the value on the left side is greater than or equal to the value on the right. For example: [if(roll >= 17, "Hit!", "Miss")]
  • <: "is less than"; use this to see if the value on the left side is less than the value on the right. For example, [if(roll < 19, "Miss", "Hit!")]}
  • <=: "is less than or equal to"; use this to see if the value on the left side is less than or equal to the value on the right. For example: [if(roll <= 18, "normal hit", "critical hit")]
  • !=: "is not equal to"; use this to compare whether the value on the left side is not equal to the value on the right. Note that this operator doesn't care what the values actually are, only that they are not equal. For example, [if(roll != 1, "Not a fumble", "You fumbled!")]
  • ==: 「～と等しい」 これは両方の値が等しいことを確認するための演算子だ。間違いやすいので注意して欲しいが、等号は二つ並んでいる（等号一つは、左辺値が変数であることを表すときに使われることを思い出して欲しい）。比較の例はこのようになる。[if(hit == "yes", "命中！", "外した！")]
  • >: 「～より大きい」 これは左辺値が右辺値よりも大きいことを確認するために用いる。例えば、[if(roll > 17, "Hit!", "Miss")]という具合だ。左辺値は数値にすることもでき、その場合はこのようになる。[if(17 > roll, "外れ！", "命中！")] （これは単に最初の例を逆にしただけだ。なので、結果が真のときと偽の時の処理を逆にする必要がある）。
  • >=: 「～以上」 左辺値が右辺値以上になることを確認するためのもの。例えば、[if(roll >= 17, "命中!", "外れ")]という具合に。
  • <: 「～未満」 左辺値が右辺値未満であることを確認するときに使われる。例えば、[if(roll < 19, "外れ", "命中！")]} のように。
  • <=: 「～以下」 左辺値が右辺値以下であることを確認するときに使われる。例えば、[if(roll <= 18, "通常命中", "クリティカルヒット")] のように。
  • !=: 「～と等しくない」 左辺値と右辺値が等しくないことを調べるために使うことができる。なお、この演算子はそれぞれの値が実際にどういう値かは考慮しない点に注意。単に等しくないことだけを調べている。例えば、[if(roll != 1, "ファンブルでない", "ファンブルした！")] のように。

論理演算子

The symbols below are the logical operators. You use this to group comparisons together (you only need these if you need to make multiple comparisons at the same time). These go between individual comparisons (these don't replace the comparison operators above!).

以下に挙げる記号が論理演算子だ。これらの演算子は組み合わせて使うことができる（が、それが必要なのは一度に複数の比較を行いたい場合だけだろう）。こうした演算子は比較演算子の間で使われる（前述の比較演算子を置き換えるものではない）。

  • &&: "and"; use this if you want to make sure that two or more comparisons are all true. For example: [if(roll > 1 && roll < 20, "Hit", "Miss")] requires both comparisons to be true, for the whole comparison group to be true. In other words, the roll must be greater than 1 and less than 20 in order for it to be a hit. If both of those aren't true, the output is Miss.
    • Remember: if you use &&, every part of the comparison statement must be true for the whole comparison to be true!
  • ||: "or"; use this if you want or need only one out of multiple comparisons to be true, in order for the whole thing to be true. For example, . In the example, if either condition is true (that is, if enemyHealth is "dead" or "dying") the entire comparison group is true. Only if neither comparison is true does the whole thing become false.
    • Remember: use || if you only need one out of several comparisons to be true
  • &&: 「かつ」 これは複数の比較が全て真になるかどうかを確かめるときに用いる。例えば、[if(roll > 1 && roll < 20, "命中", "外れ")]とした場合、二つの比較の両方とも真となり、比較群全体としても真となることが求められている。 言い換えると、命中するためには、ダイスの出目は１より大きくて、かつ、２０未満でなければならないことになる。この両方が真にならない場合、出力結果は外れになる。
    • 注意： 全ての比較条件を && で結んだ場合、その全てが真にならないと、全体の結果も真にならない。
  • ||: 「または」 は、複数の比較のうちどれかが真であれば、全体が真となる場合に使用する。例えば、というように。この例では、どちらかの条件が真なら（つまり、enemyHealthが"死亡"または"瀕死"なら）、比較群全体が真になる。両方とも偽である場合にのみ、全体が偽となる。
    • 注意： 複数の条件のうち一つでも真になればよいときだけ、|| を使うこと。

IF: 値を比較する

One of the most elementary ways to branch any code is the use of the idea of if - then. That is, if some comparison is true, then do something else. You would use the if concept to say "If my attack hits, then show the damage result!"

あらゆるコードで使われる中でも最も基本的な分岐の方法はif - thenだ。つまり、if(もし)何らかの比較結果が真になる、then(なら)何か特別なことをする。このifは、「もし、私の攻撃が命中したら、ダメージ値を表示する！」というように使うことになるだろう。

MapTool's macro language has two kinds of if - a function (a function is a pre-defined set of instructions that you can "call" by referring to it by name), and a roll option (a roll option is a "switch" or "toggle" that tells MapTool how to handle a command.

MapToolのマクロ言語には二種類の if がある。―関数とロール・オプションだ。関数とは、あらかじめ定義されている一連の命令のことで、名前をつかってそれを「呼び出す」ことができる。ロール・オプションとは、MapToolに対してある命令の扱い方を教えるための「スイッチ」とか「トグル」のことだ。

if() 関数

The if() function is called simply by writing if() and putting the thing you want compared, what to do if the comparison is true, and what to do if the comparison is false, all inside the parentheses. The general format is:

if() 関数は単にif()と書いて、比較すべきものと、その結果が真になったときにすることと、偽になったときにすることを、全てカッコの中に入れるだけで使える。基本的な文法はこうなる：

if(comparison, value_if_true, value_if_false)

if(比較, 真のときの値, 偽の時の値)

An actual example would look like:

そして実際の例はこんな風になる： 

[if(attackHits == "yes", "You hit!", "You missed")]
[if(attackHits == "yes", "命中！", "外れ")]


In that single line, we've said:

この一行でやらせていることは以下のとおり：

  • Check the variable attackHits to see if it has the value "yes"
  • If it has the value "yes", then print You hit! to chat, or
  • If it does not have the value "yes", then prin You missed to chat
  • 変数attackHits の値が"yes"かどうかを確認
  • 値が"yes"なら命中！ 、
  • 値が"yes"でないなら外れ と、チャットに表示する。
The value_if_true and value_if_false parts of the if() statement can be text, dice roll commands (like 1d6 or 1d20), or variables. What they cannot be is variable assignments - that is, you can't write an if() statement like this:

if()関数の中の、真の時の値と偽の時の値の二つの部分はテキストでも、ダイスロール・コマンド（1d6とか1d20とか）でも、変数でも構わない。そこに入れてはいけないのは、変数の代入だ。つまり、if()をこういう風には書けないことになる： 

[if(attackHits=="yes", output = "You Hit!", output = "You missed")]
[if(attackHits=="yes", output = "命中！", output = "外れ")]
It may seem like a good idea, but it won't work - MapTool will give what's known as a null pointer exception, and the macro will fail. However, there is a trick to get around that: since if() is a function, and all functions - when they run - produce a value, you can assign the result of it to a variable! You would do it like this:

一見よさそうに見えるが、これはうまくいかない。これをやると、MapToolは俗に「ヌルポインター例外」と呼ばれるものを出し、マクロはエラーを起こしてしまう。しかし、これをうまく回避するワザもある。if()は関数であり、すべての関数は実行すると値を返すのだから、その戻り値を変数に代入することができるんだ。こんな風に： 

[output = if(attackHits=="yes", "You Hit!", "You missed")]
[output = if(attackHits=="yes", "命中！", "はずれ")]
When you do it that way, MapTool will:

このように書いておくと、MapToolはこんな風に動く：

  • First, decide what the result of the if() is, and
  • Second, assign that result to the variable output, which you can then use like any variable
  • まず、if()の値を求め、それから
  • 次に、その戻り値を変数outputに代入し、それを他の変数と同じようにいろいろ使う

[if():] ロール・オプション

In addition to if(), there is another way to employ the concept of "if-then" in macro code. The [if():] roll option. Roll options are, as mentioned above, effectively "switches" or "toggles" that you set for a macro command that affect how MapTool will handle it. A couple simple roll options are mentioned in the Introduction to Macro Writing - things like [h:] and [e:] for hidden or expanded output, for example.

if()の他にも、「もし～ならば～」の概念をマクロ・コードで使う方法がもう一つある。それが[if():]のロール・オプションだ。ロール・オプションとは、前述したとおり、あらかじめ与えておいたマクロ・コマンドの扱い方をMapToolに「切り替え」あるいは「トグル」させるためのものだ。Introduction to Macro Writingにはそのいくつかが載っている。[h:]や[e:]などがそれだ。

Roll options must follow these rules:

ロール・オプションは以下の規則に従わねばならない：

  1. Appear at the beginning of a macro command
  2. If only one roll option is on the line, it ends with a colon. For example: [h:]
  3. If multiple roll option are on the same command, they are separated by commas, and the last one is followed by a colon. For example, [h,if(HP > 0): command]
  4. If a roll option takes an argument - that is, it has parentheses and wants you to put something in them, like a comparison - the colon (or comma, if there are multiple roll options) goes after the parentheses. Look at the examples below to see how it's used.
  1. マクロ・コマンドの先頭につける
  2. その行内に現れるロール・オプションが'一つだけなら、オプションはコロンで終わる。例：[h:]
  3. 同じに現れるロール・オプションが複数あるなら、コンマで区切り、最後にコロンをつける。例：[h,if(HP > 0): command]
  4. ロール・オプションが引数を持つ場合、つまり、比較をするときのように、そのオプションには小カッコがついていて、その中に何かを入れたい場合、コロン（複数のロール・オプションがある場合はコンマも）はその小カッコの後ろに来る。どうなるかは以下の例を見て欲しい。
To use the [if():] option as a comparison, you must follow the format:

[if():]オプションを比較に使う場合、以下の文法を使わなければならない： 

[if(comparison): command_if_true; command_if_false]
[if(比較): 真のときのコマンド; 偽の時のコマンド]
  • Comparison: this is a comparison statement, as used in the if() above.
  • Command_if_true: this is the command to execute if true; in this form of IF, you can do variable assignments or commands that you cannot do in the if() method. However, it doesn't have to be a whole command - it can still be a bit of text.
  • Command_if_false: this is the command to execute if false. This is an optional statement - if you want it to do nothing if the comparison is false, then leave off the semicolon and the command_if_false part entirely.
  • 比較： これは比較文を表している。前述したif()で使われたのと同じだ。
  • 真のときのコマンド： これは真の時に実行されるコマンドを表す。この形式のIFでは、コマンドだけでなく、if()では不可能だった変数への代入ができる。なお、この部分はコマンドでなくても構わない。テキストでもいいのだ。
  • 偽のときのコマンド： これは偽の時に実行されるコマンドを表す。この部分はオプショナルであり、比較結果が偽のときにしたいことがなければ、セミコロンも、その後ろの偽のときのコマンドも書かなくていい。
An example of the use of the [if():] roll option might be:

[if():]ロール・オプションの例は以下の通りだ： 

[h,if(attackHits == "yes"): output="You hit!"; output="You missed"]
Result of your attack: [r:output]
[h,if(attackHits == "yes"): output="命中！"; output="外れ"]
攻撃結果: [r:output]
In the above example, the following things are happening:

上の例では、以下のように処理されている：

  • MapTool compares the value of attackHits to the value "yes"
    • If the comparison is true - that is, the value of attackHits is indeed equal to "yes" - it assigns the value "You hit!" to the variable output.
    • If the comparison is false - the value of attackHits is not equal to "yes" - it assigns the value "You missed" to the variable output.
  • It then prints a short line of text and the value of output to chat.
  • MapToolはattackHitsの値と"yes"の値とを比較する
    • 比較結果が真になったら、つまり、attackHitsが本当に"yes"と等しいなら、変数outputに"命中！"の値を代入する。
    • 比較結果が偽になったら、つまり、{code|attackHits}}が"yes"と等しくないなら、変数outputに"外れ"の値を代入する。
  • そして、短いテキストとoutputの値をチャットに表示する。
You'll note that the first line - the line that uses if - has two roll options on the same line: [h:] and [if():]. You'll also see that they are separated by a comma, and the colon goes after the last roll option, and before the commands in the command_if_true and command_if_false sections.

１行目で気づいた人もいるだろう。ここでは一つの行で、[h:] と [if():]の二つのロール・オプションを使っている。この二つのオプションはコンマで区切られていて、コロンは最後のロール・オプションの後ろ、真のときのコマンドと偽の時のコマンドのセクションの前にある。

IF と CODE

So what if you want to do more than one thing based on a comparison? Say, set a bunch of variables to a certain value? For that, you use the [code():] roll option.

比較の結果としてやりたいことが複数あったらどうしたらいいだろうか？ 例えば、複数の変数にそれぞれ値を代入するとか？ それには[code():]ロール・オプションが使える。

Like all roll options, [code():] is put at the beginning of the line, separated from other roll options by a comma. Macro programming convention (that is, the way most macro writers seem to do it) is to put [code():] as the last roll option in the list. So, the general format you will see in a macro is likely to be:

他のロール・オプションと同じように、[code():]は行の先頭に置き、他のロール・オプションとはコンマで区切る。マクロプログラミング規約（要は、ほとんどのマクロがそうなってるって意味だ）では、[code():] をロール・オプションの一番最後につけることになっている。だから、マクロの中では一般にはこんな風になる： 

[roll_option1, roll_option2, code: macro_commands]
[roll_option1, roll_option2, code: macro_commands]
The second component of the [code():] option is the curly bracket ({ }). You use these to enclose multiple commands as a single group. Remember the format of the [if():] roll option?

[code():]オプションの二番目の要素は中カッコ（{}）だ。これを使って複数のコマンドを一つの群にまとめる。[if():]ロール・オプションの文法を覚えているかな？ 

[if(comparison): command_if_true; command_if_false]
[if(comparison): 真のときのコマンド; 偽のときのコマンド]
Well, the [code():] option lets you replace command_if_true and command_if_false with multiple macro commands. Let's look at an example:

さて、[code():]オプションでは 真のときのコマンド と 偽のときのコマンド に複数のマクロ・コマンドを置くことができる。例を見てみよう：

Suppose we write a macro to look at a variable called attackRoll. We want to compare it to a number (the target number), which is held by the variable targetNumber. Here's what we want the macro to do:

これからattackRollという変数の値を調べるマクロを書くとしよう。そしてこれをある値（目標値）と比較しようと考えている。この値はtargetNumberという変数に格納されている。マクロにやらせたいのはこういうことだ：

If attackRoll is greater than or equal to targetNumber, the macro should:
  • Set attackUsed to "yes"
  • Set attackResult to "hits"
  • Set attackRecharge to 3
  • Set damageRoll to the result of the dice roll 1d8+4.
  • Output a string telling the user the results.

もし attackRoll が targetNumber 以上なら：

  • attackUsed に "yes" をセット
  • attackResult に "命中" をセット
  • attackRecharge に 3 をセット
  • damageRoll には 1d8+4　の結果をセット
  • ユーザーにその結果を知らせる文字列を表示する
If attackRoll is not greater than or equal to targetNumber, the macro should:
  • Set attackUsed to "Yes"
  • Set attackResult to "misses"
  • Set attackRecharge to 3
  • Set damageRoll to "no"
  • Output a string to chat telling the user the results.

もし attackRoll が targetNumber未満なら：

  • attackUsed に "yes" をセット
  • attackResult に "外れ" をセット
  • attackRecharge に 3 をセット
  • damageRoll には "no" をセット
  • ユーザーにその結果を知らせる文字列を表示する
Here's how to do it:

では、以下にそのマクロを載せる： 

[h:attackRoll = 1d20]
[h:targetNumber = 15]

[h,if(attackRoll >= targetNumber), code:
{
  [attackUsed = "yes"]
  [attackResult = "hits"]
  [attackRecharge = 3]
  [damageRoll = 1d8+4]
};
{
  [attackUsed = "yes"]
  [attackResult = "misses"]
  [attackRecharge = 3]
  [damageRoll = "no"]
}]

Your attack [attackResult], and you do [damageRoll] damage. Your attack will recharge in [attackRecharge] rounds.
[h:attackRoll = 1d20]
[h:targetNumber = 15]

[h,if(attackRoll >= targetNumber), code:
{
  [attackUsed = "yes"]
  [attackResult = "命中"]
  [attackRecharge = 3]
  [damageRoll = 1d8+4]
};
{
  [attackUsed = "yes"]
  [attackResult = "外れ"]
  [attackRecharge = 3]
  [damageRoll = 0]
}]

あなたの攻撃は [attackResult] で、与えたダメージは [damageRoll] 点。 次の攻撃ができるまで [attackRecharge] ラウンドかかる。


There's a lot going on here, but the important thing to look for is the CODE option in the very first line, and the curly braces. The curly braces enclose multiple separate commands, but say to MapTool, "treat these as one thing". So in the example above:

ここではいろいろなことをしているが、注目して欲しいのは一番最初の行にある CODE オプションと、中カッコだ。中カッコの中には複数のコマンドが入っているが、MapToolに対してこれを「一つのものとして扱う」よう指示していることになる。従って、上の例はこのように動作する：

  • We declare two variables, attackRoll and targetNumber, and give them initial values (in this case, attackRoll will be the result of a 1d20 roll, and targetNumber is set to 15).
  • We set up the comparison (putting an h, in front - remember, that will hide the results from chat, so you don't see all the calculations in the if statement).
  • We put [code():] in there to warn MapTool that each part of the [if():] roll option - command_if_true and command_if_false - will actually consist of multiple separate commands.
  • We put a colon after the word code, to mark off the end of all the roll options. There is only ONE colon in the line!
  • We use a { to mark the start of the command_if_true portion of the IF statement. We then put in our commands, each one separately and enclosed in square brackets. Once finished, we close that section of the IF statement with a }, and put a semicolon on the end (remember, the IF roll option needs a semicolon to separate command_if_true from command_if_false.
  • We do the same process for the command_if_false section - a { followed by a series of commands, and then closed with a }.
  • We make sure to close off the whole if statement with another square bracket ( ] ). Remember, an IF roll option is still just a macro command, and all macro commands must be enclosed in [ ].
  • Finally, we write some text, with the several variables we have inserted at appropriate points, to be sent to chat when the macro runs.
  • 二つの変数 attackRoll と targetNumber を宣言し、初期値を与える（この場合、attackRoll は 1d20 の結果、targetNumber は15になるはずだ）。
  • 比較条件を設定する（まず最初に h を置く。このオプションをつけるとその結果をチャットに表示しなくなる。従って、この if 文の計算結果は見えなくなる）。
  • [if():]ロール・オプションの中の、真のときのコマンド と 偽のときのコマンドのそれぞれの部分に[code():]を置いて、この部分の中には複数のコマンドが入るのだということをMapToolにあらかじめ報せておく。
  • code文の後ろにコロンを置き、ロール・オプションの終端であることを知らせる。この行にあるコロンはこれ一つだけ！
  • IF文の中の、真のときのコマンド の最初に { を置く。それからそれぞれ大カッコでくくったコマンドを並べていく。全部終わったら、このセクションを } で閉じ、最後にセミコロンをつける（ IF ロール・オプションでは、真のときのコマンド と 偽のときのコマンド を区切るのにセミコロンが必要だということを思い出して欲しい）
  • 上と同じ作業を 偽のときのコマンド のセクションについても行う。 { の後に一連のコマンドを並べ、最後に } で閉じる。
  • ここでこの if 文全体を大カッコ（ ] ）でくくっておくこと。 IF ロール・オプションもマクロ・コマンドの一つであり、全てのマクロ・コマンドは[ ]でくくられていなければならない。
  • 最後に、それぞれの変数を適当な場所に埋め込んだテキストを書き、マクロが実行されたときにチャットに送り込まれるようにしておく
NOTE: The CODE roll option only works with other roll options. You would not use this with the if() function. That is a bit confusing, but just remember: CODE only goes with other roll options.

注意： CODE ロール・オプションは他のロール・オプションと組み合わせたときにだけ動作する。関数であるif() とは組み合わせられない。ちょっとややこしいかも知れないが、「 CODE は ロール・オプションと組み合わせてしか使えない」とだけ、覚えておいて欲しい。

SWITCH: 複数の選択肢の中から選ぶ

The if() function and the [if():] roll option both let you pick from two options - either do something when the comparison is true, or do something different when the comparison is false. But life - and RPG's - are not always so black and white. When you want to do different things based on one of many options, you use the [switch():] roll option.

if()関数と[if():]ロール・オプションは両方とも二つある処理のどちらか一つを選ぶものだ。比較結果が真ならこちら、偽ならこちらという具合に。しかし人生というものは、そしてRPGもだが、常に白黒はっきりしたものではない。複数の選択肢の中から異なった動作を一つ選ぶ場合には、[switch():]ロール・オプションを使いたまえ。

The general format is:

一般的な文法は以下の通り： 

[switch(val):
case case_value1: command_1;
case case_value2: command_2;
case case_value3: command_3;
default: command_Default]
[switch(val):
case 第1の値: 第1のコマンド;
case 第2の値: 第2のコマンド;
case 第3の値: 第3のコマンド;
default: デフォルトのコマンド]


What's happening here is this:

MapToolはこういう風に動作する：

  • MapTool is looking at the value of the variable val
  • MapTool then looks at each of the case statements in the switch, and compares val to case_value1, case_value2, and case_value3
  • When MapTool finds a match - that is, val is equal to one of those cases, the appropriate command (either command_1, command_2, or command_3) is executed, and then MapTool exits the switch statement (which just means, once it's found a match, it does what that case says, and then stops checking for matches).
  • 変数 val の値を調べる
  • それから switch の中の case 文を一つ一つ見ていって、val を 第1の値、第2の値、第3の値 と比較する
  • 一致する値が見つかったら、つまり val が case 文のどれかと等しくなったら、それに該当するコマンドを（第1のコマンド、第2のコマンド、第3のコマンドのいずれかを）実行する。それが終わったら、switch 文を抜ける（要は、一致するものを探して、そこに書いてある通りのことをして、そこで探すのをやめる、ということだ）。
Suppose, for example, that the we wanted a macro that would automatically assign the right Armor value to a token, based on the token's Class. If you've been following along, you might recognize the Armor value as one of the attributes in the Sample Ruleset. If you visit the Sample Ruleset page, you'll see that a character can have one of several armor values, based on the character's class:

例えば、あるトークンに対して、そのClassに応じた正しいArmor値を自動的に代入するマクロが欲しいと仮定してみる。ここまで読んできてくれたのなら、ここでいうArmor値はSample Rulesetにある属性値の一つだということが分かってもらえるだろう。Sample Rulesetのページを読めば、キャラクターが自分のクラスに応じていくつかの装甲値(armor value)のなかから一つを選べることが分かるはずだ：

  • A Warrior has an armor value of 6
  • A Rogue has an armor value of 2
  • A Wizard has an armor value of 1
  • A Priest has an armor value of 4
  • A Warrior の装甲値は 6
  • A Rogue の装甲値は 2
  • A Wizard の装甲値は 1
  • A Priest の装甲値は 4
So, let's say we want a macro to ask us for the value of the variable class, and then use that variable to assign the right Armor value. Here's how we'd do it:

そこで、マクロがそのトークンのclassを質問してくるようにして、その後で正しいArmor値を代入するようしよう。こういう風になる： 

[h:class = "Rogue"]

[h,switch(class):
case "Warrior": Armor = 6;
case "Rogue": Armor = 2;
case "Wizard": Armor = 1;
case "Priest": Armor = 4;
default: Armor = 0]

Your Armor Value is [Armor].
[h:class = "Rogue"]

[h,switch(class):
case "Warrior": Armor = 6;
case "Rogue": Armor = 2;
case "Wizard": Armor = 1;
case "Priest": Armor = 4;
default: Armor = 0]

あなたの装甲値は [Armor]　です。
What the above example does is:

この例で何をやっているかというと、こういうことだ：

  • Look at the value for class - if you try this out, it will always show the value for "Rogue." If you alter the [h:class="Rogue"] line, you can see how changing that value affects the switch statement).
  • Compare what you put in there with the four different cases - checking to see if class is equal to "Warrior", "Rogue", "Wizard", or "Priest".
  • If class equals any of those (and we mean EXACTLY equals - case sensitive, no spaces, an exact match), run the command to set the variable Armor to the appropriate value.
  • If no match is found, do whatever follows the default option (in other words, set Armor to 0.
  • Stop looking for matches, and move on.
  • class 変数の値を調べる。このマクロを試しに動かしてみると、常に "Rogue" の値を表示してくるだろう。[h:class="Rogue"] の行を変更すれば、それが switch 文にどういう影響を与えるか、分かるはずだ。
  • ここで代入したものを、他の４つの case と比較する。classの値が"Warrior"、"Rogue"、"Wizard"、"Priest"、のどれと等しいか調べる。
  • class が上のどれかと同じ値であれば（ここでいう同じとは、「全く同じ」ということだ。大文字小文字やスペースの有無にいたるまで、全く同じでなければならない）、対応するコマンドを実行して、Armor に正しい値を与える。
  • どれとも一致しなかった場合、default の後ろにあるとおりに実行する（ここでは、Armor に 0 をセットする）。
  • そこで探すのを止めて、次の処理へと移動する。

SWITCH と CODE を組み合わせる

The [code():] option can be used with a [switch():] option, in a similar manner as [if():]. There are a couple tricky bits, but if you follow the pattern given in the examples, it should work for you.

以前に [if():] でもできたように、[code():] は [switch():] とも組み合わせることができる。多少ややこしいが、例に挙がっているパターンにさえ従っていれば、うまく動いてくれる。

To do a [switch():] option with [code():], the general format is:

[code():] と [switch ():] とを組み合わせる場合、基本的な文法は以下の通りだ： 

[switch(val),code:
case case_1: { commands_for_case_1};
case case_2: { commands_for_case_2};
case case_3: { commands_for_case_3};
default: { commands_for_default}]
[switch(val),code:
case 第1のケース: { 第1のケースのコマンド };
case 第2のケース: { 第３のケースのコマンド　};
case 第3のケース: { 第３のケースのコマンド　};
default: { デフォルトのコマンド}]
An actual example can be drawn from the Sample Ruleset as well. Not only does a character's class indicate his or her armor value, but also the list of "Beginning Powers" from which the character can draw. Suppose we wanted to set not only the armor value, but also a variable called beginningPowers. To do that, you'd write a SWITCH that looks like:

これは Sample Ruleset からそのまま引いてきたもう一つの実例だ。キャラクターのクラスが決めるのは装甲値だけでなく、そのキャラクターが選択できる「作成時パワー」のリストもそれで決まる。装甲値以外にも beginningPowers 変数も代入したいと仮定する。これを行うには、SWITCH 文を以下のように書けばいい： 

[h,switch(class),code:
case "Warrior":
{
  [Armor = 6]
  [beginningPowers = "Sword, Shield Bash, Bow, Shield, Torch"]
};
case "Rogue":
{
  [Armor = 2]
  [beginningPowers = "Dagger, Hide, Backstab, Pick Lock, Torch"]
};
case "Wizard":
{
  [Armor = 1]
  [beginningPowers = "Dagger, Staff, Light, Lightning Bolt, Fire Ball"]
};
case "Priest":
{
  [Armor = 4]
  [beginningPowers = "Mace, Heal, Protect, Banish Undead, Torch"]
};
default:
{
  [Armor = 0]
  [beginningPowers = "Fists, Feet"]
}]

Your Armor Value is [Armor] and your beginning powers are [beginningPowers].
[h,switch(class),code:
case "Warrior":
{
  [Armor = 6]
  [beginningPowers = "Sword, Shield Bash, Bow, Shield, Torch"]
};
case "Rogue":
{
  [Armor = 2]
  [beginningPowers = "Dagger, Hide, Backstab, Pick Lock, Torch"]
};
case "Wizard":
{
  [Armor = 1]
  [beginningPowers = "Dagger, Staff, Light, Lightning Bolt, Fire Ball"]
};
case "Priest":
{
  [Armor = 4]
  [beginningPowers = "Mace, Heal, Protect, Banish Undead, Torch"]
};
default:
{
  [Armor = 0]
  [beginningPowers = "Fists, Feet"]
}]

あなたの装甲値は [Armor] で、開始時パワーのリストは [beginningPowers] です。
As you can see, each different case is treated as a single block of operations - so you need to put curly braces for each separate case, and separate them all with the semicolon. At the very end, we put a closing square bracket (]), to finish the whole command. Again, what has happened is that the CODE option and the curly braces have allowed you to replace a single command, like command_for_case_1, with a group of commands.

お分かりのように、それぞれのケースが一つの処理として扱われている。だからそれぞれのケースは中カッコで囲み、セミコロンで区切っておかなければならない。そして一番最後を大カッコ（]）で閉じ、コマンド全体を区切る。ここでも、CODE オプションを使うことで、第1のケースのコマンド のコマンドを、コマンドの「グループ」で置き換えることができる。

Also, you'll see that I've added in some line breaks so that each separate group of operations is easier to read - MapTool is cool with that, because extra line breaks inside a command (remember, commands are enclosed within [ ]) are ignored. This is nice, because it makes the macros much easier to read.

なお、読みやすくするために、それぞれの処理グループごとに改行を入れているのが分かると思う。ここはMapToolのいいところで、一つのコマンドの中での改行を無視してくれる（一つのコマンドは、[ と ] で囲まれているという点に注意）。これはマクロを大幅に読みやすくできて、都合がいい。

高度な分岐オプション

The two options illustrated above are the most common branching options used in macro writing. However, they are not the only options for branching macros - there are two others, which involve either leaving one macro entirely to call on another, or changing the focus (that is, what token is the Current Token) of a macro temporarily. Since these are fairly complex operations all on their own, you'll find them in the More Branching Options guide.

ここで説明した二つのオプションは、マクロを書くときに最もよく使われる分岐方法だ。しかし、マクロで分岐を行う手段はこれだけではない。他にも二つのオプションがあるが、その中には、あるマクロの中から完全に抜け出して別のマクロを呼び出したり、マクロのフォーカスを切り替える（つまり、マクロのCurrent Tokenが表すトークンを一時的に変える）ものが含まれている。こうした処理はそれ単体でもやや複雑なものなので、この先のMore Branching Optionsガイドで読むことにする。

Languages:  English  • 日本語

Retrieved from "https://wiki.rptools.info/index.php?title=Introduction_to_Macro_Branching/ja&oldid=8314"