Verb:find

Called on This asset in a phrase such as "find 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_find_this: "Found custom string at thing_one.try_find_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_find_this: {
       "Player Two": "Found custom string at thing_one.try_find_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "find 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_find_this: "Found custom string at thing_one.do_find_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_find_this: {
       "Player Two": "Found custom string at thing_one.do_find_this['Player Two']",
     },
   });
   

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

try_find_this_preposition_that mirrors try_find_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 "with" as the preposition, but any preposition can set a unique response.

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_find_this_with_that: "Found custom string at thing_one.try_find_this_with_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_find_this_with_that: {
       "Thing Two": "Found custom string at thing_one.try_find_this_with_that['Thing Two']",
     },
   });
   

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

do_find_this_preposition_that mirrors do_find_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 "with" as the preposition, but any preposition can set a unique response.

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_find_this_with_that: "Found custom string at thing_one.do_find_this_with_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_find_this_with_that: {
       "Thing Two": "Found custom string at thing_one.do_find_this_with_that['Thing Two']",
     },
   });
   

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

try_find_that_preposition_this mirrors try_find_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 "with" as the preposition, but any preposition can set a unique response.

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_find_that_with_this: "Found custom string at thing_two.try_find_that_with_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_find_that_with_this: {
       "Thing One": "Found custom string at thing_two.try_find_that_with_this['Thing One']",
     },
   });
   

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

do_find_that_preposition_this mirrors do_find_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 "with" as the preposition, but any preposition can set a unique response.

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_find_that_with_this: "Found custom string at thing_two.do_find_that_with_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_find_that_with_this: {
       "Thing One": "Found custom string at thing_two.do_find_that_with_this['Thing One']",
     },
   });
   

Called on This asset in a phrase such as "find 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",
     tryFindThis: function () {
       let msg = "Found custom method at thing_one.tryFindThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryFindThis 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",
     tryFindThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.tryFindThis['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",
     tryFindThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.tryFindThis('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 "find 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",
     doFindThis: function () {
       let msg = "Found custom method at thing_one.doFindThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doFindThis 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",
     doFindThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.doFindThis['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",
     doFindThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.doFindThis('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 "find this with that", where This is the direct object and That is the indirect object.

tryFindThisPrepositionThat mirrors tryFindThatPrepositionThis. 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 "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 what That asset is.

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

2. To limit the method to act only on a certain asset, change the value of tryFindThisPrepositionThat 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",
     tryFindThisWithThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.tryFindThisWithThat['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",
     tryFindThisWithThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.tryFindThisWithThat('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 "find this with that", where This is the direct object and That is the indirect object.

doFindThisPrepositionThat mirrors doFindThatPrepositionThis. 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 "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 what That asset is.

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

2. To limit the method to act only on a certain asset, change the value of doFindThisPrepositionThat 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",
     doFindThisWithThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.doFindThisWithThat['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",
     doFindThisWithThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.doFindThisWithThat('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 "find this with that", where That is the indirect object and This is the direct object.

tryFindThatPrepositionThis mirrors tryFindThisPrepositionThat. 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 "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 what That asset is.

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

2. To limit the method to act only on a certain asset, change the value of tryFindThatPrepositionThis 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",
     tryFindThatWithThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.tryFindThatWithThis['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",
     tryFindThatWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.tryFindThatWithThis('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 "find this with that", where That is the indirect object and This is the direct object.

doFindThatPrepositionThis mirrors doFindThisPrepositionThat. 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 "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 what That asset is.

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

2. To limit the method to act only on a certain asset, change the value of doFindThatPrepositionThis 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",
     doFindThatWithThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.doFindThatWithThis['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",
     doFindThatWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.doFindThatWithThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });