Verb:jump

Called on every object in the input, including the player character, regardless of prepositions or sentence structure.

MyGame.createAsset({
  class: "Thing",
  name: "Thing One",
  try_jump: "Found custom string at thing_one.try_jump",
});

Called on every object in the input, including the player character, regardless of prepositions or sentence structure.

MyGame.createAsset({
  class: "Thing",
  name: "Thing One",
  do_jump: "Found custom string at thing_one.do_jump",
});

Called on This asset in a phrase such as "jump this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_this: "Found custom string at thing_one.try_jump_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_this: {
       "Player Two": "Found custom string at thing_one.try_jump_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "jump this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_this: "Found custom string at thing_one.do_jump_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_this: {
       "Player Two": "Found custom string at thing_one.do_jump_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "jump this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_with_this: "Found custom string at thing_one.try_jump_with_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_with_this: {
       "Player Two": "Found custom string at thing_one.try_jump_with_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "jump this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_with_this: "Found custom string at thing_one.do_jump_with_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_with_this: {
       "Player Two": "Found custom string at thing_one.do_jump_with_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "jump this that", where This is the direct object and That is the indirect object.

try_jump_this_that mirrors try_jump_that_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_this_that: "Found custom string at thing_one.try_jump_this_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_this_that: {
       "Thing Two": "Found custom string at thing_one.try_jump_this_that['Thing Two']",
     },
   });
   

Called on This asset in a phrase such as "jump this that", where This is the direct object and That is the indirect object.

do_jump_this_that mirrors do_jump_that_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_this_that: "Found custom string at thing_one.do_jump_this_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_this_that: {
       "Thing Two": "Found custom string at thing_one.do_jump_this_that['Thing Two']",
     },
   });
   

Called on That asset in a phrase such as "jump this that".

try_jump_that_this mirrors try_jump_this_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_jump_that_this: "Found custom string at thing_two.try_jump_that_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_jump_that_this: {
       "Thing One": "Found custom string at thing_two.try_jump_that_this['Thing One']",
     },
   });
   

Called on That asset in a phrase such as "jump this that".

do_jump_that_this mirrors do_jump_this_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_jump_that_this: "Found custom string at thing_two.do_jump_that_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_jump_that_this: {
       "Thing One": "Found custom string at thing_two.do_jump_that_this['Thing One']",
     },
   });
   

Called on This asset in a phrase such as "jump from this to that", where This is the direct object and That is the indirect object.

try_jump_preposition_this_preposition_that mirrors try_jump_preposition_that_preposition_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_from_this_to_that: "Found custom string at thing_one.try_jump_from_this_to_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_jump_from_this_to_that: {
       "Thing Two": "Found custom string at thing_one.try_jump_from_this_to_that['Thing Two']",
     },
   });
   

Called on This asset in a phrase such as "jump from this to that", where This is the direct object and That is the indirect object.

do_jump_preposition_this_preposition_that mirrors dojump_preposition_that_preposition_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_from_this_to_that: "Found custom string at thing_one.do_jump_from_this_to_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_jump_from_this_to_that: {
       "Thing Two": "Found custom string at thing_one.do_jump_from_this_to_that['Thing Two']",
     },
   });
   

Called on That asset in a phrase such as "jump from this to that", where That is the indirect object and This is the direct object.

try_jump_preposition_that_preposition_this mirrors try_jump_preposition_this_preposition_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_jump_from_that_to_this: "Found custom string at thing_two.try_jump_from_that_to_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for This particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_jump_from_that_to_this: {
       "Thing One": "Found custom string at thing_two.try_jump_from_that_to_this['Thing One']",
     },
   });
   

Called on That asset in a phrase such as "jump from this to that", where That is the indirect object and This is the direct object.

do_jump_preposition_that_preposition_this mirrors do_jump_preposition_this_preposition_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_jump_from_that_to_this: "Found custom string at thing_two.do_jump_from_that_to_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for This particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_jump_from_that_to_this: {
       "Thing One": "Found custom string at thing_two.do_jump_from_that_to_this['Thing One']",
     },
   });
   

Called on every object in the input, including the player character, regardless of prepositions or sentence structure.

MyGame.createAsset({
  class: "Player",
  name: "Player One",
  tryJump: function (params) {
    let msg = "Found custom method at player_one.tryJump()";
    MyGame.print(msg);
  },
});

Called on every object in the input, including the player character, regardless of prepositions or sentence structure.

MyGame.createAsset({
  class: "Player",
  name: "Player One",
  doJump: function (params) {
    let msg = "Found custom method at player_one.doJump()";
    MyGame.print(msg);
  },
});

Called on This asset in a phrase such as "jump this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThis: function () {
       let msg = "Found custom method at thing_one.tryJumpThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryJumpThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.tryJumpThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.tryJumpThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThis: function () {
       let msg = "Found custom method at thing_one.doJumpThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doJumpThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.doJumpThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.doJumpThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump on this". Since no indirect object is given, we treat the player character as an indirect object. This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpWithThis: function () {
       let msg = "Found custom method at thing_one.tryJumpWithThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryJumpPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpWithThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.tryJumpWithThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.tryJumpWithThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump on this". Since no indirect object is given, we treat the player character as an indirect object. This example uses "with" as the preposition, but any preposition can set a unique response.

Note that sentence structures are commonly mutated during the doTry verb phase, so try and do may act on different sentence structures.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpWithThis: function () {
       let msg = "Found custom method at thing_one.doJumpWithThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doJumpPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpWithThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.doJumpWithThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.doJumpWithThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump this that".

tryJumpThisThat mirrors tryJumpThatThis. One is called on a direct object; the other on an indirect object. These are equivalents. Where you place your code is a matter of preference.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThisThat: function () {
       let msg = "Found custom method at thing_one.tryJumpThisThat()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryJumpThisThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThisThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.tryJumpThisThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThisThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.tryJumpThisThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump this that". doJumpThisThat mirrors doJumpThatThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThisThat: function () {
       let msg = "Found custom method at thing_one.doJumpThisThat()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doJumpThisThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThisThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.doJumpThisThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThisThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.doJumpThisThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "jump this that".

tryJumpThatThis mirrors tryJumpThisThat. One is called on an indirect object; the other on a direct object. These are equivalents. Where you place your code is a matter of preference.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpThatThis: function () {
       let msg = "Found custom method at thing_one.tryJumpThatThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryJumpThatThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryJumpThatThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.tryJumpThatThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryJumpThatThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.tryJumpThatThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "jump this that".

doJumpThatThis mirrors doJumpThisThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpThatThis: function () {
       let msg = "Found custom method at thing_one.doJumpThatThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doJumpThatThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doJumpThatThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.doJumpThatThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doJumpThatThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.doJumpThatThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump from this to that", where This is the direct object and That is the indirect object.

tryJumpPrepositionThisPrepositionThat mirrors tryJumpPrepositionThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpFromThisToThat: function () {
       let msg = "Found custom method at thing_one.tryJumpFromThisToThat()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryJumpPrepositionThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpFromThisToThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.tryJumpFromThisToThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryJumpFromThisToThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.tryJumpFromThisToThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "jump from this to that", where This is the direct object and That is the indirect object.

doJumpPrepositionThisPrepositionThat mirrors doJumpPrepositionThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpFromThisToThat: function () {
       let msg = "Found custom method at thing_one.doJumpFromThisToThat()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doJumpPrepositionThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpFromThisToThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.doJumpFromThisToThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doJumpFromThisToThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.doJumpFromThisToThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "jump from this to that", where This is the direct object and That is the indirect object.

tryJumpPrepositionThatPrepositionThis mirrors tryJumpPrepositionThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "from" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryJumpToThatFromThis: function () {
       let msg = "Found custom method at thing_two.tryJumpToThatFromThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryJumpPrepositionThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryJumpToThatFromThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.tryJumpToThatFromThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryJumpToThatFromThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.tryJumpToThatFromThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "jump from this to that", where This is the direct object and That is the indirect object.

doJumpPrepositionThatPrepositionThis mirrors doJumpPrepositionThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "from" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doJumpToThatFromThis: function () {
       let msg = "Found custom method at thing_two.doJumpToThatFromThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doJumpPrepositionThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doJumpToThatFromThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.doJumpToThatFromThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doJumpToThatFromThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.doJumpToThatFromThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });